@scriptc/cli-darwin-arm64 0.2.5 → 0.2.6

package/dist/lib/runtime-sources/src/scr_map.c

@@ -187,13 +187,82 @@ static bool scr_map_key_eq(const ScrMap *m, uint64_t stored, uint64_t probe) {
  * A zero entry hash marks a tombstone; cached hashes reject unrelated keys
  * before equality and survive table growth without hashing the keys again.
  * Remap zero to one so every live entry has a nonzero hash. */
-static size_t scr_map_probe(const ScrMap *m, uint64_t hash, uint64_t key) {
+typedef enum { SCR_MAP_LOOKUP_STR, SCR_MAP_LOOKUP_SPAN, SCR_MAP_LOOKUP_WORD, SCR_MAP_LOOKUP_GENERIC } ScrMapLookup;
+
+typedef struct { const char *bytes; size_t length; } ScrMapSpan;
+
+/* Choose equality once per operation. Inlining the traversal with a constant
+ * lookup kind keeps the ordinary string/word probe free of key-kind dispatch,
+ * while boxed keys retain their complete value/identity semantics. */
+static inline bool scr_map_lookup_eq(const ScrMap *m, uint64_t stored, uint64_t key,
+                                     ScrMapLookup lookup) {
+  if (lookup == SCR_MAP_LOOKUP_WORD) return stored == key;
+  if (lookup == SCR_MAP_LOOKUP_SPAN) {
+    const ScrStr *a = scr_map_slot_to_ptr(stored);
+    const ScrMapSpan *b = scr_map_slot_to_ptr(key);
+    return a->len == b->length && scr_key_equal(a->data, b->bytes, a->len);
+  }
+  if (lookup == SCR_MAP_LOOKUP_STR) {
+    const ScrStr *a = scr_map_slot_to_ptr(stored);
+    const ScrStr *b = scr_map_slot_to_ptr(key);
+    return a == b || (a->len == b->len && scr_key_equal(a->data, b->data, a->len));
+  }
+  return scr_map_key_eq(m, stored, key);
+}
+
+/* Compact tables keep a hash fingerprint beside each 24-bit entry index.
+ * Rejecting a collision here avoids loading an unrelated ordered entry.
+ * Larger tables keep full-width indices; collection size remains limited
+ * only by the allocator. Zero is empty in compact tables, so store index+1. */
+#ifndef SCR_MAP_COMPACT_BUCKETS
+#define SCR_MAP_COMPACT_BUCKETS ((size_t)1 << 24)
+#endif
+_Static_assert(SCR_MAP_COMPACT_BUCKETS >= 16 &&
+               SCR_MAP_COMPACT_BUCKETS <= ((size_t)1 << 24) &&
+               (SCR_MAP_COMPACT_BUCKETS & (SCR_MAP_COMPACT_BUCKETS - 1)) == 0,
+               "compact bucket capacity must leave room for every tagged index");
+#define SCR_MAP_INDEX_MASK UINT32_C(0x00ffffff)
+
+static bool scr_map_compact_buckets(size_t count) {
+  return count <= SCR_MAP_COMPACT_BUCKETS;
+}
+
+static size_t scr_map_bucket(const ScrMap *m, size_t slot) {
+  if (scr_map_compact_buckets(m->nbuckets)) {
+    uint32_t index = ((const uint32_t *)m->buckets)[slot] & SCR_MAP_INDEX_MASK;
+    return index ? (size_t)index - 1 : SCR_MAP_EMPTY;
+  }
+  return ((const size_t *)m->buckets)[slot];
+}
+
+static void scr_map_bucket_set(ScrMap *m, size_t slot, size_t entry, uint64_t hash) {
+  if (scr_map_compact_buckets(m->nbuckets)) {
+    ((uint32_t *)m->buckets)[slot] = (uint32_t)(entry + 1) | (uint32_t)(hash >> 32 & UINT32_C(0xff000000));
+  } else {
+    ((size_t *)m->buckets)[slot] = entry;
+  }
+}
+
+static inline __attribute__((always_inline)) size_t scr_map_probe_with(
+    const ScrMap *m, uint64_t hash, uint64_t key, ScrMapLookup lookup) {
   if (m->nbuckets == 0) return SCR_MAP_EMPTY;
   size_t mask = m->nbuckets - 1;
+  if (scr_map_compact_buckets(m->nbuckets)) {
+    const uint32_t *buckets = m->buckets;
+    uint32_t tag = (uint32_t)(hash >> 32 & UINT32_C(0xff000000));
+    for (size_t i = hash & mask;; i = (i + 1) & mask) {
+      uint32_t bucket = buckets[i];
+      if (!bucket) return i;
+      if ((bucket & ~SCR_MAP_INDEX_MASK) != tag) continue;
+      size_t b = (bucket & SCR_MAP_INDEX_MASK) - 1;
+      if (m->entries[b].hash == hash && scr_map_lookup_eq(m, m->entries[b].key, key, lookup)) return i;
+    }
+  }
+  const size_t *buckets = m->buckets;
   for (size_t i = hash & mask;; i = (i + 1) & mask) {
-    size_t b = m->buckets[i];
+    size_t b = buckets[i];
     if (b == SCR_MAP_EMPTY) return i;
-    if (m->entries[b].hash == hash && scr_map_key_eq(m, m->entries[b].key, key)) return i;
+    if (m->entries[b].hash == hash && scr_map_lookup_eq(m, m->entries[b].key, key, lookup)) return i;
   }
 }
 
@@ -201,24 +270,103 @@ static size_t scr_map_probe(const ScrMap *m, uint64_t hash, uint64_t key) {
 
 /* Small collections keep only their ordered entries. Cached hashes make
  * the bounded scan cheap without allocating a separate bucket table. */
-static size_t scr_map_find(const ScrMap *m, uint64_t hash, uint64_t key) {
+static inline __attribute__((always_inline)) size_t scr_map_find_with(
+    const ScrMap *m, uint64_t hash, uint64_t key, ScrMapLookup lookup) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
   hash = hash ? hash : 1;
   if (m->nbuckets == 0) {
     for (size_t e = 0; e < m->nentries; e++) {
-      if (m->entries[e].hash == hash && scr_map_key_eq(m, m->entries[e].key, key)) return e;
+      if (m->entries[e].hash == hash && scr_map_lookup_eq(m, m->entries[e].key, key, lookup)) return e;
     }
     return SCR_MAP_EMPTY;
   }
-  size_t slot = scr_map_probe(m, hash, key);
-  return slot == SCR_MAP_EMPTY ? SCR_MAP_EMPTY : m->buckets[slot];
+  size_t slot = scr_map_probe_with(m, hash, key, lookup);
+  return slot == SCR_MAP_EMPTY ? SCR_MAP_EMPTY : scr_map_bucket(m, slot);
+}
+
+static ScrMapLookup scr_map_lookup_kind(const ScrMap *m) {
+  switch (m->key_kind) {
+  case SCR_MAP_KEY_STR: return SCR_MAP_LOOKUP_STR;
+  case SCR_MAP_KEY_F64:
+  case SCR_MAP_KEY_BOOL:
+  case SCR_MAP_KEY_REF:
+  case SCR_MAP_KEY_NULL:
+  case SCR_MAP_KEY_UNDEFINED: return SCR_MAP_LOOKUP_WORD;
+  default: return SCR_MAP_LOOKUP_GENERIC;
+  }
+}
+
+static size_t scr_map_probe(const ScrMap *m, uint64_t hash, uint64_t key) {
+  switch (scr_map_lookup_kind(m)) {
+  case SCR_MAP_LOOKUP_STR: return scr_map_probe_with(m, hash, key, SCR_MAP_LOOKUP_STR);
+  case SCR_MAP_LOOKUP_WORD: return scr_map_probe_with(m, hash, key, SCR_MAP_LOOKUP_WORD);
+  default: return scr_map_probe_with(m, hash, key, SCR_MAP_LOOKUP_GENERIC);
+  }
+}
+
+static size_t scr_map_find(const ScrMap *m, uint64_t hash, uint64_t key) {
+  switch (scr_map_lookup_kind(m)) {
+  case SCR_MAP_LOOKUP_STR: return scr_map_find_with(m, hash, key, SCR_MAP_LOOKUP_STR);
+  case SCR_MAP_LOOKUP_WORD: return scr_map_find_with(m, hash, key, SCR_MAP_LOOKUP_WORD);
+  default: return scr_map_find_with(m, hash, key, SCR_MAP_LOOKUP_GENERIC);
+  }
+}
+
+static size_t scr_map_find_f64(const ScrMap *m, double key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  uint64_t k = scr_map_f64_bits(key);
+  return scr_map_find_with(m, scr_map_hash_word(k), k, SCR_MAP_LOOKUP_WORD);
+}
+
+static size_t scr_map_find_str(const ScrMap *m, const ScrStr *key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  if (m->nbuckets == 0) {
+    uint64_t k = scr_map_slot_from_ptr((void *)key);
+    for (size_t e = 0; e < m->nentries; e++) {
+      if (m->entries[e].hash && scr_map_lookup_eq(m, m->entries[e].key, k, SCR_MAP_LOOKUP_STR)) return e;
+    }
+    return SCR_MAP_EMPTY;
+  }
+  return scr_map_find_with(m, scr_map_hash_str(key), scr_map_slot_from_ptr((void *)key),
+                           SCR_MAP_LOOKUP_STR);
+}
+
+/* A transient input span follows the same hash, equality and ownership
+ * rules as a string key without allocating or copying the probe. */
+static size_t scr_map_find_span(const ScrMap *m, const char *bytes, size_t length) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  ScrMapSpan key = { bytes, length };
+  return scr_map_find_with(m, scr_key_hash(bytes, length), scr_map_slot_from_ptr(&key),
+                           SCR_MAP_LOOKUP_SPAN);
+}
+
+bool scr_map_get_span_f64(const ScrMap *m, const char *bytes, size_t length, double *out) {
+  size_t e = scr_map_find_span(m, bytes, length);
+  if (e == SCR_MAP_EMPTY) return false;
+  *out = scr_map_slot_to_f64(m->entries[e].val);
+  return true;
+}
+
+bool scr_map_get_span_bool(const ScrMap *m, const char *bytes, size_t length, bool *out) {
+  size_t e = scr_map_find_span(m, bytes, length);
+  if (e == SCR_MAP_EMPTY) return false;
+  *out = m->entries[e].val != 0;
+  return true;
+}
+
+void *scr_map_get_span_ref(const ScrMap *m, const char *bytes, size_t length) {
+  size_t e = scr_map_find_span(m, bytes, length);
+  return e == SCR_MAP_EMPTY ? NULL : m->val_retain(scr_map_slot_to_ptr(m->entries[e].val));
 }
 
 /* Rebuild the bucket table (size must be a power of two >= 2 * nentries):
  * only live entries are inserted, in dense order — dead markers vanish. */
 static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) {
-  size_t *buckets = malloc(nbuckets * sizeof *buckets);
+  bool compact = scr_map_compact_buckets(nbuckets);
+  size_t bytes = nbuckets * (compact ? sizeof(uint32_t) : sizeof(size_t));
+  void *buckets = malloc(bytes);
   if (!buckets) scr_map_oom();
-  for (size_t i = 0; i < nbuckets; i++) buckets[i] = SCR_MAP_EMPTY;
+  memset(buckets, compact ? 0 : 0xff, bytes);
   free(m->buckets);
   m->buckets = buckets;
   m->nbuckets = nbuckets;
@@ -227,8 +375,8 @@ static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) {
     uint64_t hash = m->entries[e].hash;
     if (!hash) continue;
     size_t i = hash & mask;
-    while (buckets[i] != SCR_MAP_EMPTY) i = (i + 1) & mask;
-    buckets[i] = e;
+    while (scr_map_bucket(m, i) != SCR_MAP_EMPTY) i = (i + 1) & mask;
+    scr_map_bucket_set(m, i, e, hash);
   }
 }
 
@@ -370,23 +518,28 @@ ScrMap *scr_map_retain(ScrMap *m) {
   return m;
 }
 
+static void scr_map_destroy(void *object) {
+  ScrMap *m = object;
+  scr_weak_dispose(m);
+  for (size_t e = 0; e < m->nentries; e++) {
+    if (!m->entries[e].hash) continue;
+    scr_map_release_key(m, m->entries[e].key);
+    scr_map_release_val(m, m->entries[e].val);
+  }
+  free(m->entries);
+  free(m->buckets);
+#ifdef SCR_RC_AUDIT
+  scr_live_maps--;
+#endif
+  if (m->key_trace || m->val_trace) scr_cyc_free(m);
+  else free(m);
+}
+
 void scr_map_release(ScrMap *m) {
   if (!m || m->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
   if (--m->rc == 0) {
-    scr_weak_dispose(m);
     if (m->key_trace || m->val_trace) scr_cyc_on_dead(m);
-    for (size_t e = 0; e < m->nentries; e++) {
-      if (!m->entries[e].hash) continue;
-      scr_map_release_key(m, m->entries[e].key);
-      scr_map_release_val(m, m->entries[e].val);
-    }
-    free(m->entries);
-    free(m->buckets);
-#ifdef SCR_RC_AUDIT
-    scr_live_maps--;
-#endif
-    if (m->key_trace || m->val_trace) scr_cyc_free(m);
-    else free(m);
+    scr_rc_destroy(m, scr_map_destroy);
   } else if (m->key_trace || m->val_trace) {
     scr_cyc_on_release(m); /* possible cycle root; may collect — m is done */
   }
@@ -414,19 +567,21 @@ void scr_map_clear(ScrMap *m) {
      * after the clear append past them and ARE visited (Node-exact). */
     m->nentries = 0;
   }
-  for (size_t i = 0; i < m->nbuckets; i++) m->buckets[i] = SCR_MAP_EMPTY;
+  if (m->nbuckets) {
+    bool compact = scr_map_compact_buckets(m->nbuckets);
+    memset(m->buckets, compact ? 0 : 0xff,
+           m->nbuckets * (compact ? sizeof(uint32_t) : sizeof(size_t)));
+  }
 }
 
 /* ── has / delete ──────────────────────────────────────────────────────── */
 
 bool scr_map_has_f64(const ScrMap *m, double key) {
-  uint64_t k = scr_map_f64_bits(key);
-  return scr_map_find(m, scr_map_hash_word(k), k) != SCR_MAP_EMPTY;
+  return scr_map_find_f64(m, key) != SCR_MAP_EMPTY;
 }
 
 bool scr_map_has_str(const ScrMap *m, const ScrStr *key) {
-  uint64_t k = scr_map_slot_from_ptr((void *)key);
-  return scr_map_find(m, scr_map_hash_str(key), k) != SCR_MAP_EMPTY;
+  return scr_map_find_str(m, key) != SCR_MAP_EMPTY;
 }
 
 static bool scr_map_delete_found(ScrMap *m, size_t e) {
@@ -439,19 +594,21 @@ static bool scr_map_delete_found(ScrMap *m, size_t e) {
 }
 
 bool scr_map_delete_f64(ScrMap *m, double key) {
-  uint64_t k = scr_map_f64_bits(key);
-  return scr_map_delete_found(m, scr_map_find(m, scr_map_hash_word(k), k));
+  return scr_map_delete_found(m, scr_map_find_f64(m, key));
 }
 
 bool scr_map_delete_str(ScrMap *m, const ScrStr *key) {
-  uint64_t k = scr_map_slot_from_ptr((void *)key);
-  return scr_map_delete_found(m, scr_map_find(m, scr_map_hash_str(key), k));
+  return scr_map_delete_found(m, scr_map_find_str(m, key));
 }
 
 /* REF keys: identity hashing over the pointer bits (see the header's
  * SCR_MAP_KEY_REF note). Probes never retain; storage does. */
 static size_t scr_map_find_ref(const ScrMap *m, const void *key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
   uint64_t k = scr_map_slot_from_ptr((void *)key);
+  if (m->key_kind == SCR_MAP_KEY_REF) {
+    return scr_map_find_with(m, scr_map_hash_word(k), k, SCR_MAP_LOOKUP_WORD);
+  }
   return scr_map_find(m, scr_map_hash_key(m, k), k);
 }
 
@@ -472,7 +629,7 @@ bool scr_map_delete_ref(ScrMap *m, const void *key) {
 static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
   hash = hash ? hash : 1;
   size_t slot = scr_map_probe(m, hash, key);
-  size_t e = m->nbuckets == 0 ? scr_map_find(m, hash, key) : m->buckets[slot];
+  size_t e = m->nbuckets == 0 ? scr_map_find(m, hash, key) : scr_map_bucket(m, slot);
   if (e != SCR_MAP_EMPTY) {
     uint64_t old = m->entries[e].val;
     m->entries[e].val = val; /* unlink before releasing (cycle collector) */
@@ -486,7 +643,7 @@ static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
   if (m->nbuckets && (m->nentries != old_entries || m->nbuckets != old_buckets)) {
     size_t mask = m->nbuckets - 1;
     slot = hash & mask;
-    while (m->buckets[slot] != SCR_MAP_EMPTY) slot = (slot + 1) & mask;
+    while (scr_map_bucket(m, slot) != SCR_MAP_EMPTY) slot = (slot + 1) & mask;
   }
   size_t idx = m->nentries++;
   m->entries[idx].key = key;
@@ -513,7 +670,7 @@ static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
   } else if (scr_map_ref_key(m->key_kind)) {
     m->key_retain(scr_map_slot_to_ptr(key)); /* key is borrowed */
   }
-  if (m->nbuckets) m->buckets[slot] = idx;
+  if (m->nbuckets) scr_map_bucket_set(m, slot, idx, hash);
 }
 
 static void scr_map_set_f64_key(ScrMap *m, double key, uint64_t val) {
@@ -570,15 +727,6 @@ ScrMap *scr_set_new_ref(void *(*elem_retain)(void *), void (*elem_release)(void
 
 /* ── get ───────────────────────────────────────────────────────────────── */
 
-static size_t scr_map_find_f64(const ScrMap *m, double key) {
-  uint64_t k = scr_map_f64_bits(key);
-  return scr_map_find(m, scr_map_hash_word(k), k);
-}
-
-static size_t scr_map_find_str(const ScrMap *m, const ScrStr *key) {
-  return scr_map_find(m, scr_map_hash_str(key), scr_map_slot_from_ptr((void *)key));
-}
-
 bool scr_map_get_f64_f64(const ScrMap *m, double key, double *out) {
   size_t e = scr_map_find_f64(m, key);
   if (e == SCR_MAP_EMPTY) return false;
@@ -641,8 +789,9 @@ void *scr_map_get_ref_ref(const ScrMap *m, const void *key) {
 
 /* Boolean keys use unboxed 0/1 slots and the same probe path. */
 static size_t scr_map_find_bool(const ScrMap *m, bool key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
   uint64_t slot = key ? 1 : 0;
-  return scr_map_find(m, scr_map_hash_word(slot), slot);
+  return scr_map_find_with(m, scr_map_hash_word(slot), slot, SCR_MAP_LOOKUP_WORD);
 }
 
 bool scr_map_has_bool(const ScrMap *m, bool key) {