swiss_hash 0.1.1 → 0.1.3

data/ext/swiss_hash/swiss_hash.c

@@ -12,6 +12,20 @@
 #endif
 #endif
 
+#ifndef RB_LIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RB_LIKELY(x) __builtin_expect(!!(x), 1)
+#else
+#define RB_LIKELY(x) (x)
+#endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define SH_ALWAYS_INLINE static inline __attribute__((always_inline))
+#else
+#define SH_ALWAYS_INLINE static inline
+#endif
+
 #if defined(__GNUC__) || defined(__clang__)
 #define SH_PREFETCH(p) __builtin_prefetch((const void *)(p), 0, 1)
 #else
@@ -20,6 +34,7 @@
 
 static uint64_t swiss_hash_seed0;
 static uint64_t swiss_hash_seed1;
+static VALUE cSwissHashHash;
 
 static void init_hash_seed(void) {
     VALUE seed_val = rb_hash(INT2FIX(0));
@@ -131,119 +146,126 @@ 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
+#define GROUP_SIZE 16
 #elif defined(__aarch64__) || defined(_M_ARM64)
 #define SWISS_USE_NEON 1
 #include <arm_neon.h>
-
-#define GROUP_SIZE  8
-#define GROUP_MASK  0xFFu
+#define GROUP_SIZE 16
 #else
-#define SWISS_USE_PORTABLE 1
-#define GROUP_SIZE  8
-#define GROUP_MASK  0xFFu
+#define SWISS_USE_SWAR 1
+#define GROUP_SIZE     8
+#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)
 
-static inline uint32_t neon_movemask(uint8x8_t v) {
-    static const uint8_t power_of_two[8] = {1, 2, 4, 8, 16, 32, 64, 128};
-    uint8x8_t bits = vand_u8(v, vld1_u8(power_of_two));
-    bits = vpadd_u8(bits, bits);
-    bits = vpadd_u8(bits, bits);
-    bits = vpadd_u8(bits, bits);
-    return (uint32_t)vget_lane_u8(bits, 0);
+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;
 }
 
-static inline uint8x8_t ctrl_load(const uint8_t *ctrl) {
-    return vld1_u8(ctrl);
+SH_ALWAYS_INLINE ctrl_vec_t ctrl_load(const uint8_t *ctrl) {
+    return vld1q_u8(ctrl);
 }
 
-static inline uint32_t ctrl_match_h2_vec(uint8x8_t cv, uint8_t h2) {
-    return neon_movemask(vceq_u8(cv, vdup_n_u8(h2)));
+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)));
 }
 
-static inline uint32_t ctrl_match_empty_vec(uint8x8_t cv) {
-    return neon_movemask(vceq_u8(cv, vdup_n_u8(CTRL_EMPTY)));
+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)));
 }
 
-static inline uint32_t ctrl_match_empty_or_deleted_vec(uint8x8_t cv) {
-    uint8x8_t msb = vshr_n_u8(cv, 7);
-    uint8x8_t match = vceq_u8(msb, vdup_n_u8(1));
-    return neon_movemask(match);
+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)));
 }
 
-static inline uint32_t ctrl_match_empty(const uint8_t *ctrl) {
+SH_ALWAYS_INLINE ctrl_mask_t ctrl_match_empty(const uint8_t *ctrl) {
     return ctrl_match_empty_vec(ctrl_load(ctrl));
 }
 
-#else /* portable */
+#else /* SWAR */
 
-static inline uint32_t ctrl_match_h2_raw(const uint8_t *ctrl, uint8_t h2) {
+#define SWAR_LSB 0x0101010101010101ULL
+#define SWAR_MSB 0x8080808080808080ULL
+
+SH_ALWAYS_INLINE uint32_t ctrl_bitmask_from_msb(uint64_t msb_bits) {
+    uint64_t bits = (msb_bits & SWAR_MSB) >> 7;
+    return (uint32_t)((bits * 0x0102040810204080ULL) >> 56);
+}
+
+SH_ALWAYS_INLINE uint32_t ctrl_match_h2_raw(const uint8_t *ctrl, uint8_t h2) {
     uint64_t c;
     memcpy(&c, ctrl, 8);
-    uint64_t broadcast = 0x0101010101010101ULL * h2;
+    uint64_t broadcast = SWAR_LSB * h2;
     uint64_t xored = c ^ broadcast;
-    uint64_t result = (xored - 0x0101010101010101ULL) & ~xored & 0x8080808080808080ULL;
-    uint32_t mask = 0;
-    for (int i = 0; i < 8; i++) {
-        if (result & (0x80ULL << (i * 8)))
-            mask |= (1u << i);
-    }
-    return mask;
+    uint64_t result = (xored - SWAR_LSB) & ~xored & SWAR_MSB;
+    return ctrl_bitmask_from_msb(result);
 }
 
-static inline uint32_t ctrl_match_empty_raw(const uint8_t *ctrl) {
-    uint32_t mask = 0;
-    for (int i = 0; i < 8; i++) {
-        if (ctrl[i] == CTRL_EMPTY)
-            mask |= (1u << i);
-    }
-    return mask;
+SH_ALWAYS_INLINE uint32_t ctrl_match_empty_raw(const uint8_t *ctrl) {
+    uint64_t c;
+    memcpy(&c, ctrl, 8);
+    return ctrl_bitmask_from_msb((c & ~(c << 6)) & SWAR_MSB);
 }
 
-static inline uint32_t ctrl_match_empty_or_deleted_raw(const uint8_t *ctrl) {
-    uint32_t mask = 0;
-    for (int i = 0; i < 8; i++) {
-        if (ctrl[i] & 0x80)
-            mask |= (1u << i);
-    }
-    return mask;
+SH_ALWAYS_INLINE uint32_t ctrl_match_empty_or_deleted_raw(const uint8_t *ctrl) {
+    uint64_t c;
+    memcpy(&c, ctrl, 8);
+    return ctrl_bitmask_from_msb(c);
 }
 
-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_raw(ctrl);
 }
 
-#endif /* SIMD selection */
+#endif /* control-byte matching selection */
+
+#ifndef CTRL_MASK_SLOT
+typedef uint32_t ctrl_mask_t;
+#define CTRL_MASK_SLOT(m) ctz32(m)
+#endif
 
-static inline int ctz32(uint32_t v) {
+#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);
 #elif defined(_MSC_VER)
@@ -260,6 +282,21 @@ static 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;
@@ -277,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
 
-static 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;
@@ -327,56 +369,92 @@ static inline uint64_t compute_hash(VALUE key) {
 #define H1(hash) ((hash) >> 7)
 #define H2(hash) ((uint8_t)((hash) & H2_MASK))
 
-static inline int keys_equal(VALUE a, VALUE b) {
-    if (a == b) return 1;
-    if (FIXNUM_P(a) || SYMBOL_P(a) || SPECIAL_CONST_P(a)) return 0;
+SH_ALWAYS_INLINE int strings_equal(VALUE a, VALUE b) {
+    long la = RSTRING_LEN(a);
+    if (la != RSTRING_LEN(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;
+    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;
-        }
+    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 (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);
+    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;
+    if (FIXNUM_P(a) || SYMBOL_P(a) || SPECIAL_CONST_P(a))
+        return 0;
+
+    if (RB_TYPE_P(a, T_STRING) && RB_TYPE_P(b, T_STRING)) {
+        return strings_equal(a, b);
     }
 
     return rb_eql(a, b);
 }
 
-static inline VALUE prepare_key(VALUE key) {
+#ifndef SWISS_HASH_COPY_STRING_KEYS
+#define SWISS_HASH_COPY_STRING_KEYS 1
+#endif
+
+SH_ALWAYS_INLINE VALUE prepare_key(VALUE key) {
     if (RB_TYPE_P(key, T_STRING)) {
+#if SWISS_HASH_COPY_STRING_KEYS
         if (!OBJ_FROZEN(key)) {
             key = rb_str_new_frozen(key);
         }
-
-        rb_enc_str_coderange(key);
+#endif
     }
     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) {
+    if (sh->ctrl) {
+        swiss_free_arrays(sh);
+    }
+
     size_t min_groups = (min_capacity + GROUP_SIZE - 1) / GROUP_SIZE;
     size_t num_groups = 1;
     while (num_groups < min_groups)
@@ -385,7 +463,22 @@ static void swiss_init(SwissHash *sh, size_t min_capacity) {
         num_groups = 2;
 
     size_t capacity = num_groups * GROUP_SIZE;
+    uint8_t *ctrl = NULL;
+    Slot *slots = NULL;
+
+    if (!swiss_alloc_block(capacity, &ctrl, &slots)) {
+        sh->capacity = 0;
+        sh->num_groups = 0;
+        sh->group_mask = 0;
+        sh->size = 0;
+        sh->growth_left = 0;
+        sh->tombstone_count = 0;
+        sh->mutating = 0;
+        rb_raise(rb_eNoMemError, "failed to allocate SwissHash");
+    }
 
+    sh->ctrl = ctrl;
+    sh->slots = slots;
     sh->num_groups = num_groups;
     sh->group_mask = num_groups - 1;
     sh->capacity = capacity;
@@ -393,18 +486,6 @@ 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);
 }
 
@@ -414,7 +495,7 @@ typedef struct {
     size_t group_mask;
 } ProbeSeq;
 
-static inline ProbeSeq probe_start(uint64_t h1, size_t group_mask) {
+SH_ALWAYS_INLINE ProbeSeq probe_start(uint64_t h1, size_t group_mask) {
     ProbeSeq ps;
     ps.group_idx = (size_t)(h1)&group_mask;
     ps.stride = 0;
@@ -422,40 +503,82 @@ static inline ProbeSeq probe_start(uint64_t h1, size_t group_mask) {
     return ps;
 }
 
-static inline void probe_next(ProbeSeq *ps) {
+SH_ALWAYS_INLINE void probe_next(ProbeSeq *ps) {
     ps->stride++;
     ps->group_idx = (ps->group_idx + ps->stride) & ps->group_mask;
 }
 
 #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);
-#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
         while (match) {
-            int slot = ctz32(match);
+            int slot = CTRL_MASK_SLOT(match);
             Slot *s = &sh->slots[off + slot];
-            if (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;
@@ -467,23 +590,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);
 
-static 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);
@@ -494,44 +669,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;
-
-    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);
-        }
+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;
+
+    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);
@@ -540,44 +758,41 @@ 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);
-#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);
+        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
-        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;
-            if (keys_equal(sh->slots[idx].key, key)) {
-                sh->slots[idx].value = value;
+            Slot *s = &sh->slots[idx];
+            if (RB_LIKELY(s->key == key) || (!identity_only && keys_equal(s->key, key))) {
+                s->value = value;
                 return value;
             }
             match &= match - 1;
         }
 
         if (insert_idx == (size_t)-1 && avail) {
-            insert_idx = off + ctz32(avail);
+            insert_idx = off + (size_t)CTRL_MASK_SLOT(avail);
         }
 
         if (empty)
@@ -585,112 +800,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);
+        }
+    }
+
+    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);
     }
-    sh->ctrl[insert_idx] = h2;
-    sh->slots[insert_idx].key = key;
-    sh->slots[insert_idx].value = value;
-    sh->size++;
 
-    MUTATE_GUARD_END(sh);
+    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);
-#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
         while (match) {
-            int slot = ctz32(match);
+            int slot = CTRL_MASK_SLOT(match);
             size_t idx = off + slot;
-            if (keys_equal(sh->slots[idx].key, key)) {
-                VALUE old_value = sh->slots[idx].value;
-
-                MUTATE_GUARD_BEGIN(sh);
+            Slot *s = &sh->slots[idx];
+            if (RB_LIKELY(s->key == key) || (!identity_only && keys_equal(s->key, key))) {
+                VALUE old_value = s->value;
                 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));
-
-    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");
+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)");
     }
 
-    memset(sh->ctrl, CTRL_EMPTY, new_cap);
+    CallbackCtx ctx = {sh, key, Qnil, Qnil, NULL};
+    if (!key_may_callback(key)) {
+        return swiss_delete_unlocked((VALUE)&ctx);
+    }
 
-    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;
+    swiss_lock(sh);
+    rb_ensure(swiss_delete_unlocked, (VALUE)&ctx, swiss_unlock_ensure, (VALUE)sh);
+    return ctx.result;
+}
 
-    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);
-        }
-    }
+typedef struct {
+    SwissHash *sh;
+    size_t new_num_groups;
+} RebuildCall;
 
-    free(old_ctrl);
-    free(old_slots);
+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);
+}
+
+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) {
@@ -750,9 +1025,42 @@ static VALUE swiss_hash_initialize(int argc, VALUE *argv, VALUE self) {
     return self;
 }
 
+static VALUE swiss_hash_initialize_copy(VALUE self, VALUE original) {
+    if (self == original) {
+        return self;
+    }
+
+    SwissHash *src;
+    SwissHash *dst;
+    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;
+    }
+
+    swiss_init(dst, src->capacity);
+    memcpy(dst->ctrl, src->ctrl, src->capacity * sizeof(uint8_t));
+    memcpy(dst->slots, src->slots, src->capacity * sizeof(Slot));
+    dst->size = src->size;
+    dst->growth_left = src->growth_left;
+    dst->tombstone_count = src->tombstone_count;
+    dst->mutating = 0;
+
+    return self;
+}
+
 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 (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);
@@ -760,7 +1068,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;
 }
 
@@ -838,15 +1151,546 @@ static VALUE swiss_hash_values(VALUE self) {
     return ary;
 }
 
+static VALUE swiss_hash_each_key(VALUE self) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            rb_yield(sh->slots[i].key);
+        }
+    }
+
+    return self;
+}
+
+static VALUE swiss_hash_each_value(VALUE self) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            rb_yield(sh->slots[i].value);
+        }
+    }
+
+    return self;
+}
+
+static VALUE swiss_hash_to_h(VALUE self) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    VALUE hash = rb_hash_new();
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            rb_hash_aset(hash, sh->slots[i].key, sh->slots[i].value);
+        }
+    }
+
+    return hash;
+}
+
+static VALUE swiss_hash_to_a(VALUE self) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    VALUE ary = rb_ary_new_capa(sh->size);
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE pair = rb_ary_new_capa(2);
+            rb_ary_push(pair, sh->slots[i].key);
+            rb_ary_push(pair, sh->slots[i].value);
+            rb_ary_push(ary, pair);
+        }
+    }
+
+    return ary;
+}
+
+static VALUE swiss_hash_fetch(int argc, VALUE *argv, VALUE self) {
+    VALUE key;
+    VALUE default_value;
+    rb_scan_args(argc, argv, "11", &key, &default_value);
+
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
+    VALUE *val = swiss_lookup(sh, key);
+    if (val) {
+        return *val;
+    }
+
+    if (rb_block_given_p()) {
+        if (argc == 2) {
+            rb_warn("block supersedes default value argument");
+        }
+        return rb_yield(key);
+    }
+
+    if (argc == 2) {
+        return default_value;
+    }
+
+    VALUE inspected = rb_inspect(key);
+    VALUE message = rb_str_plus(rb_str_new_cstr("key not found: "), inspected);
+    rb_exc_raise(rb_exc_new_str(rb_eKeyError, message));
+
+    return Qnil;
+}
+
+static VALUE swiss_hash_values_at(int argc, VALUE *argv, VALUE self) {
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
+    VALUE ary = rb_ary_new_capa((long)argc);
+
+    for (int i = 0; i < argc; i++) {
+        VALUE *val = swiss_lookup(sh, argv[i]);
+        rb_ary_push(ary, val ? *val : Qnil);
+    }
+
+    return ary;
+}
+
+static VALUE swiss_hash_value_p(VALUE self, VALUE value) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            if (RTEST(rb_equal(sh->slots[i].value, value))) {
+                return Qtrue;
+            }
+        }
+    }
+
+    return Qfalse;
+}
+
+static VALUE swiss_hash_key_for_value(VALUE self, VALUE value) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            if (RTEST(rb_equal(sh->slots[i].value, value))) {
+                return sh->slots[i].key;
+            }
+        }
+    }
+
+    return Qnil;
+}
+
 static VALUE swiss_hash_key_p(VALUE self, VALUE key) {
     SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
     VALUE *val = swiss_lookup(sh, key);
     return val ? Qtrue : Qfalse;
 }
 
+static VALUE swiss_hash_new_like(VALUE self, size_t capacity) {
+    VALUE argv[1] = {SIZET2NUM(capacity)};
+    return rb_class_new_instance(1, argv, rb_obj_class(self));
+}
+
+static VALUE swiss_hash_store_prepared(SwissHash *sh, VALUE key, VALUE value) {
+    if (RB_UNLIKELY(!(FIXNUM_P(key) || SYMBOL_P(key)))) {
+        key = prepare_key(key);
+    }
+    return swiss_insert(sh, key, value);
+}
+
+typedef struct {
+    VALUE self;
+    SwissHash *sh;
+    int has_block;
+} MergeCtx;
+
+static void swiss_hash_merge_one_pair(MergeCtx *ctx, VALUE key, VALUE value) {
+    if (ctx->has_block) {
+        VALUE *old = swiss_lookup(ctx->sh, key);
+        if (old) {
+            value = rb_yield_values(3, key, *old, value);
+        }
+    }
+    swiss_hash_store_prepared(ctx->sh, key, value);
+}
+
+static int swiss_hash_merge_ruby_hash_i(VALUE key, VALUE value, VALUE arg) {
+    swiss_hash_merge_one_pair((MergeCtx *)arg, key, value);
+    return ST_CONTINUE;
+}
+
+static void swiss_hash_merge_swiss_hash(MergeCtx *ctx, VALUE other) {
+    SwissHash *src;
+    TypedData_Get_Struct(other, SwissHash, &swiss_hash_type, src);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            swiss_hash_merge_one_pair(ctx, src->slots[i].key, src->slots[i].value);
+        }
+    }
+}
+
+static void swiss_hash_merge_one(MergeCtx *ctx, VALUE other) {
+    if (RTEST(rb_obj_is_kind_of(other, cSwissHashHash))) {
+        swiss_hash_merge_swiss_hash(ctx, other);
+        return;
+    }
+
+    VALUE hash = rb_check_hash_type(other);
+    if (NIL_P(hash)) {
+        rb_raise(rb_eTypeError, "no implicit conversion of %s into Hash", rb_obj_classname(other));
+    }
+
+    rb_hash_foreach(hash, swiss_hash_merge_ruby_hash_i, (VALUE)ctx);
+}
+
+static VALUE swiss_hash_merge_bang(int argc, VALUE *argv, VALUE self) {
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
+    MergeCtx ctx = {self, sh, rb_block_given_p()};
+
+    for (int i = 0; i < argc; i++) {
+        swiss_hash_merge_one(&ctx, argv[i]);
+    }
+
+    return self;
+}
+
+static VALUE swiss_hash_merge(int argc, VALUE *argv, VALUE self) {
+    VALUE copy = rb_obj_dup(self);
+    swiss_hash_merge_bang(argc, argv, copy);
+    return copy;
+}
+
+static VALUE swiss_hash_replace(VALUE self, VALUE other) {
+    swiss_hash_clear(self);
+    VALUE argv[1] = {other};
+    swiss_hash_merge_bang(1, argv, self);
+    return self;
+}
+
+static VALUE swiss_hash_to_sh(VALUE self) {
+    return rb_obj_dup(self);
+}
+
+static VALUE swiss_hash_fetch_values(int argc, VALUE *argv, VALUE self) {
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
+    VALUE ary = rb_ary_new_capa((long)argc);
+    int has_block = rb_block_given_p();
+
+    for (int i = 0; i < argc; i++) {
+        VALUE *val = swiss_lookup(sh, argv[i]);
+        if (val) {
+            rb_ary_push(ary, *val);
+        } else if (has_block) {
+            rb_ary_push(ary, rb_yield(argv[i]));
+        } else {
+            VALUE key_argv[1] = {argv[i]};
+            rb_ary_push(ary, swiss_hash_fetch(1, key_argv, self));
+        }
+    }
+
+    return ary;
+}
+
+static VALUE swiss_hash_slice(int argc, VALUE *argv, VALUE self) {
+    SwissHash *src = (SwissHash *)RTYPEDDATA_DATA(self);
+    VALUE result = swiss_hash_new_like(self, (size_t)argc);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (int i = 0; i < argc; i++) {
+        VALUE *val = swiss_lookup(src, argv[i]);
+        if (val) {
+            swiss_hash_store_prepared(dst, argv[i], *val);
+        }
+    }
+
+    return result;
+}
+
+static VALUE swiss_hash_except(int argc, VALUE *argv, VALUE self) {
+    VALUE result = rb_obj_dup(self);
+    for (int i = 0; i < argc; i++) {
+        swiss_hash_delete(result, argv[i]);
+    }
+    return result;
+}
+
+static VALUE swiss_hash_invert(VALUE self) {
+    SwissHash *src;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, src);
+    VALUE result = swiss_hash_new_like(self, src->size);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            swiss_hash_store_prepared(dst, src->slots[i].value, src->slots[i].key);
+        }
+    }
+
+    return result;
+}
+
+static VALUE swiss_hash_assoc(VALUE self, VALUE object) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            if (RTEST(rb_equal(sh->slots[i].key, object))) {
+                VALUE ary = rb_ary_new_capa(2);
+                rb_ary_push(ary, sh->slots[i].key);
+                rb_ary_push(ary, sh->slots[i].value);
+                return ary;
+            }
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE swiss_hash_rassoc(VALUE self, VALUE object) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            if (RTEST(rb_equal(sh->slots[i].value, object))) {
+                VALUE ary = rb_ary_new_capa(2);
+                rb_ary_push(ary, sh->slots[i].key);
+                rb_ary_push(ary, sh->slots[i].value);
+                return ary;
+            }
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE swiss_hash_shift(VALUE self) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE key = sh->slots[i].key;
+            VALUE value = sh->slots[i].value;
+            sh->ctrl[i] = CTRL_DELETED;
+            sh->slots[i].key = Qnil;
+            sh->slots[i].value = Qnil;
+            sh->size--;
+            sh->tombstone_count++;
+
+            VALUE ary = rb_ary_new_capa(2);
+            rb_ary_push(ary, key);
+            rb_ary_push(ary, value);
+            return ary;
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE swiss_hash_delete_if(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE key = sh->slots[i].key;
+            VALUE value = sh->slots[i].value;
+            if (RTEST(rb_yield_values(2, key, value))) {
+                swiss_delete(sh, key);
+            }
+        }
+    }
+
+    return self;
+}
+
+static VALUE swiss_hash_keep_if(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE key = sh->slots[i].key;
+            VALUE value = sh->slots[i].value;
+            if (!RTEST(rb_yield_values(2, key, value))) {
+                swiss_delete(sh, key);
+            }
+        }
+    }
+
+    return self;
+}
+
+static VALUE swiss_hash_select(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *src;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, src);
+    VALUE result = swiss_hash_new_like(self, src->size);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE key = src->slots[i].key;
+            VALUE value = src->slots[i].value;
+            if (RTEST(rb_yield_values(2, key, value))) {
+                swiss_hash_store_prepared(dst, key, value);
+            }
+        }
+    }
+
+    return result;
+}
+
+static VALUE swiss_hash_reject(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *src;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, src);
+    VALUE result = swiss_hash_new_like(self, src->size);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE key = src->slots[i].key;
+            VALUE value = src->slots[i].value;
+            if (!RTEST(rb_yield_values(2, key, value))) {
+                swiss_hash_store_prepared(dst, key, value);
+            }
+        }
+    }
+
+    return result;
+}
+
+static VALUE swiss_hash_select_bang(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    size_t old_size = ((SwissHash *)RTYPEDDATA_DATA(self))->size;
+    swiss_hash_keep_if(self);
+    return ((SwissHash *)RTYPEDDATA_DATA(self))->size == old_size ? Qnil : self;
+}
+
+static VALUE swiss_hash_reject_bang(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    size_t old_size = ((SwissHash *)RTYPEDDATA_DATA(self))->size;
+    swiss_hash_delete_if(self);
+    return ((SwissHash *)RTYPEDDATA_DATA(self))->size == old_size ? Qnil : self;
+}
+
+static VALUE swiss_hash_compact(VALUE self) {
+    SwissHash *src;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, src);
+    VALUE result = swiss_hash_new_like(self, src->size);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED && !NIL_P(src->slots[i].value)) {
+            swiss_hash_store_prepared(dst, src->slots[i].key, src->slots[i].value);
+        }
+    }
+
+    return result;
+}
+
 static VALUE swiss_hash_compact_bang(VALUE self) {
     SwissHash *sh;
     TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+    size_t old_size = sh->size;
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED && NIL_P(sh->slots[i].value)) {
+            VALUE key = sh->slots[i].key;
+            swiss_delete(sh, key);
+        }
+    }
+
+    return sh->size == old_size ? Qnil : self;
+}
+
+static VALUE swiss_hash_transform_values(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *src;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, src);
+    VALUE result = swiss_hash_new_like(self, src->size);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            swiss_hash_store_prepared(dst, src->slots[i].key, rb_yield(src->slots[i].value));
+        }
+    }
+
+    return result;
+}
+
+static VALUE swiss_hash_transform_values_bang(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+
+    for (size_t i = 0; i < sh->capacity; i++) {
+        uint8_t c = sh->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            sh->slots[i].value = rb_yield(sh->slots[i].value);
+        }
+    }
+
+    return self;
+}
+
+static VALUE swiss_hash_transform_keys(VALUE self) {
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    SwissHash *src;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, src);
+    VALUE result = swiss_hash_new_like(self, src->size);
+    SwissHash *dst = (SwissHash *)RTYPEDDATA_DATA(result);
+
+    for (size_t i = 0; i < src->capacity; i++) {
+        uint8_t c = src->ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            swiss_hash_store_prepared(dst, rb_yield(src->slots[i].key), src->slots[i].value);
+        }
+    }
+
+    return result;
+}
+
+static VALUE swiss_hash_compact_storage_bang(VALUE self) {
+    SwissHash *sh;
+    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
 
     if (sh->tombstone_count > 0) {
         swiss_compact(sh);
@@ -875,7 +1719,7 @@ static VALUE swiss_hash_stats(VALUE self) {
 #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("portable/SWAR"));
+    rb_hash_aset(hash, ID2SYM(rb_intern("simd")), rb_str_new_cstr("SWAR"));
 #endif
     rb_hash_aset(hash, ID2SYM(rb_intern("layout")), rb_str_new_cstr("hybrid"));
 
@@ -887,9 +1731,11 @@ void Init_swiss_hash(void) {
 
     VALUE mSwissHash = rb_define_module("SwissHash");
     VALUE cHash = rb_define_class_under(mSwissHash, "Hash", rb_cObject);
+    cSwissHashHash = cHash;
 
     rb_define_alloc_func(cHash, swiss_hash_alloc);
     rb_define_method(cHash, "initialize", swiss_hash_initialize, -1);
+    rb_define_method(cHash, "initialize_copy", swiss_hash_initialize_copy, 1);
     rb_define_method(cHash, "[]=", swiss_hash_aset, 2);
     rb_define_method(cHash, "store", swiss_hash_aset, 2);
     rb_define_method(cHash, "[]", swiss_hash_aref, 1);
@@ -899,11 +1745,48 @@ void Init_swiss_hash(void) {
     rb_define_method(cHash, "empty?", swiss_hash_empty_p, 0);
     rb_define_method(cHash, "clear", swiss_hash_clear, 0);
     rb_define_method(cHash, "each", swiss_hash_each, 0);
+    rb_define_method(cHash, "each_pair", swiss_hash_each, 0);
+    rb_define_method(cHash, "each_key", swiss_hash_each_key, 0);
+    rb_define_method(cHash, "each_value", swiss_hash_each_value, 0);
     rb_define_method(cHash, "keys", swiss_hash_keys, 0);
     rb_define_method(cHash, "values", swiss_hash_values, 0);
+    rb_define_method(cHash, "to_h", swiss_hash_to_h, 0);
+    rb_define_method(cHash, "to_a", swiss_hash_to_a, 0);
+    rb_define_method(cHash, "fetch", swiss_hash_fetch, -1);
+    rb_define_method(cHash, "values_at", swiss_hash_values_at, -1);
+    rb_define_method(cHash, "fetch_values", swiss_hash_fetch_values, -1);
+    rb_define_method(cHash, "merge!", swiss_hash_merge_bang, -1);
+    rb_define_method(cHash, "update", swiss_hash_merge_bang, -1);
+    rb_define_method(cHash, "merge", swiss_hash_merge, -1);
+    rb_define_method(cHash, "replace", swiss_hash_replace, 1);
+    rb_define_method(cHash, "to_sh", swiss_hash_to_sh, 0);
+    rb_define_method(cHash, "slice", swiss_hash_slice, -1);
+    rb_define_method(cHash, "except", swiss_hash_except, -1);
+    rb_define_method(cHash, "invert", swiss_hash_invert, 0);
+    rb_define_method(cHash, "assoc", swiss_hash_assoc, 1);
+    rb_define_method(cHash, "rassoc", swiss_hash_rassoc, 1);
+    rb_define_method(cHash, "shift", swiss_hash_shift, 0);
+    rb_define_method(cHash, "delete_if", swiss_hash_delete_if, 0);
+    rb_define_method(cHash, "keep_if", swiss_hash_keep_if, 0);
+    rb_define_method(cHash, "select", swiss_hash_select, 0);
+    rb_define_method(cHash, "filter", swiss_hash_select, 0);
+    rb_define_method(cHash, "reject", swiss_hash_reject, 0);
+    rb_define_method(cHash, "select!", swiss_hash_select_bang, 0);
+    rb_define_method(cHash, "filter!", swiss_hash_select_bang, 0);
+    rb_define_method(cHash, "reject!", swiss_hash_reject_bang, 0);
+    rb_define_method(cHash, "compact", swiss_hash_compact, 0);
+    rb_define_method(cHash, "compact!", swiss_hash_compact_bang, 0);
+    rb_define_method(cHash, "transform_values", swiss_hash_transform_values, 0);
+    rb_define_method(cHash, "transform_values!", swiss_hash_transform_values_bang, 0);
+    rb_define_method(cHash, "transform_keys", swiss_hash_transform_keys, 0);
     rb_define_method(cHash, "key?", swiss_hash_key_p, 1);
     rb_define_method(cHash, "has_key?", swiss_hash_key_p, 1);
     rb_define_method(cHash, "include?", swiss_hash_key_p, 1);
-    rb_define_method(cHash, "compact!", swiss_hash_compact_bang, 0);
+    rb_define_method(cHash, "member?", swiss_hash_key_p, 1);
+    rb_define_method(cHash, "value?", swiss_hash_value_p, 1);
+    rb_define_method(cHash, "has_value?", swiss_hash_value_p, 1);
+    rb_define_method(cHash, "key", swiss_hash_key_for_value, 1);
+    rb_define_method(cHash, "compact_storage!", swiss_hash_compact_storage_bang, 0);
+    rb_define_method(cHash, "__compact_storage!", swiss_hash_compact_storage_bang, 0);
     rb_define_method(cHash, "stats", swiss_hash_stats, 0);
 }