perf(vm): cache Lisp-visible symbol names per heap

Repeated symbol operands acquired the global registry read lock and probed
name-object storage on every comparison. Cache the typed name view by
symbol ID on the current heap, with a publication epoch for lazily
materialized names. Keep mutable name objects live through their existing
registry roots, replace the map on heap changes, and fall back to the
registry when thread-local destruction makes the cache unavailable.

Use a map so repeated scans retain their working set: a fixed-slot trial
regressed scans larger than its capacity. Cover live mutation, exact GC,
heap changes, dump/unintern behavior, warmed large scans and thread exit.

Against d23d9f8, native symbol operand loops improve 1.51–1.65x and scans
of 4–2048 names improve 1.46–1.47x. Whole Org/indent workloads are neutral;
three isolated native query controls remain 3–10% slower, an explicit
tradeoff. GNU comparisons use bytecode, without native compilation.

Validation: 10,343 core tests passed (54 skipped), 79 focused GC-stress and
partition tests passed, 48 byte compilations succeeded with matching
retained normalized outputs, and formatting passed. Detailed measurements
and rejected-candidate evidence are in tmp/vm-symbol-names-2026-09-21/.

Author: eval-exec

crates/neovm-core/src/emacs_core/runtime/intern/mod.rs

@@ -1433,9 +1433,82 @@ pub(crate) fn unintern_canonical_id(id: SymId) -> bool {
 /// (s1)`.
 #[inline]
 pub(crate) fn resolve_lisp_visible_symbol_name(id: SymId) -> LispVisibleSymbolName {
-    global_symbol_registry()
-        .read()
-        .resolve_lisp_visible_name(id)
+    let heap_id = crate::tagged::gc::current_tagged_heap_identity().map(SymbolNameHeapId);
+    let epoch = SYMBOL_NAME_MATERIALIZATION_EPOCH.load(Ordering::Acquire);
+    let cached = VISIBLE_SYMBOL_NAME_CACHE
+        .try_with(|cache| {
+            let cache = cache.borrow();
+            if cache.heap_id != heap_id {
+                return None;
+            }
+            cache.names.get(&id).copied()
+        })
+        .ok()
+        .flatten();
+    if let Some(cached) = cached
+        && cached.epoch == epoch
+    {
+        return cached.name;
+    }
+    resolve_lisp_visible_symbol_name_uncached(id, heap_id)
+}
+
+#[derive(Clone, Copy)]
+struct VisibleSymbolNameCacheEntry {
+    epoch: u64,
+    name: LispVisibleSymbolName,
+}
+
+// Cache only names read on the current heap, without allocating a dense array
+// up to the largest process-global symbol ID. A fixed-slot cache made repeated
+// scans larger than its capacity slower by taking the miss path on every read.
+// Retain the working set instead, releasing its storage when the heap changes.
+// Store typed values, never borrowed heap strings: mutation stays live on hits.
+#[derive(Default)]
+struct VisibleSymbolNameCache {
+    heap_id: Option<SymbolNameHeapId>,
+    names: FxHashMap<SymId, VisibleSymbolNameCacheEntry>,
+}
+
+thread_local! {
+    static VISIBLE_SYMBOL_NAME_CACHE: RefCell<VisibleSymbolNameCache> =
+        RefCell::new(VisibleSymbolNameCache::default());
+}
+
+// The only transition of an existing (heap, symbol) name is Atom -> LispObject.
+// Exact names are installed when a fresh symbol ID is allocated; unintern and
+// dump restoration never replace an existing ID's name. Publishing a lazy name
+// object invalidates atom views on every thread before releasing the write lock.
+// Heap IDs are unique across heap lifetimes. Object views are already rooted by
+// the registry's per-heap index and the collector does not move their objects.
+static SYMBOL_NAME_MATERIALIZATION_EPOCH: AtomicU64 = AtomicU64::new(0);
+
+#[inline(never)]
+fn resolve_lisp_visible_symbol_name_uncached(
+    id: SymId,
+    heap_id: Option<SymbolNameHeapId>,
+) -> LispVisibleSymbolName {
+    let registry = global_symbol_registry().read();
+    let name = registry.resolve_lisp_visible_name(id);
+    // Pair the epoch with the resolved view under the same lock. Reading it
+    // after unlocking could label an old atom with a newly materialized epoch.
+    let epoch = SYMBOL_NAME_MATERIALIZATION_EPOCH.load(Ordering::Acquire);
+    drop(registry);
+    // Diagnostics can resolve names after this cache's thread-local destructor
+    // has run. The registry remains available, so caching is optional there.
+    let _ = VISIBLE_SYMBOL_NAME_CACHE.try_with(|cache| {
+        let mut cache = cache.borrow_mut();
+        if cache.heap_id != heap_id {
+            *cache = VisibleSymbolNameCache {
+                heap_id,
+                names: FxHashMap::default(),
+            };
+        }
+        cache
+            .names
+            .insert(id, VisibleSymbolNameCacheEntry { epoch, name });
+    });
+    name
 }
 
 /// Return the one Lisp name object for `id` in the current tagged heap.
@@ -1478,6 +1551,7 @@ pub(crate) fn materialize_symbol_name_value(id: SymId) -> TaggedValue {
         value: materialized,
         heap_id,
     });
+    SYMBOL_NAME_MATERIALIZATION_EPOCH.fetch_add(1, Ordering::Release);
     materialized
 }
 

crates/neovm-core/src/emacs_core/runtime/intern/tests/mod.rs

@@ -184,6 +184,73 @@ fn visible_symbol_name_reads_follow_materialization_mutation_and_gc() {
     }
 }
 
+#[test]
+fn visible_symbol_name_reads_reuse_registry_lookup_until_materialization() {
+    let mut heap = crate::tagged::gc::TaggedHeap::new();
+    crate::tagged::gc::set_tagged_heap(&mut heap);
+    let symbol = intern("visible-name-registry-read-probe");
+    reset_symbol_name_value_probes();
+    for _ in 0..64 {
+        std::hint::black_box(resolve_lisp_visible_symbol_name(symbol));
+    }
+    assert_eq!(symbol_name_value_probes(), (0, 1));
+
+    let name = materialize_symbol_name_value(symbol);
+    reset_symbol_name_value_probes();
+    for _ in 0..64 {
+        assert!(matches!(
+            resolve_lisp_visible_symbol_name(symbol),
+            LispVisibleSymbolName::LispObject(value) if value.bits() == name.bits()
+        ));
+    }
+    assert_eq!(symbol_name_value_probes(), (0, 1));
+
+    let exact_name = TaggedValue::string("visible-name-exact-registry-read-probe");
+    let exact_symbol = make_uninterned_symbol_with_name_value(exact_name);
+    reset_symbol_name_value_probes();
+    for _ in 0..64 {
+        assert!(matches!(
+            resolve_lisp_visible_symbol_name(exact_symbol),
+            LispVisibleSymbolName::LispObject(value) if value.bits() == exact_name.bits()
+        ));
+    }
+    assert_eq!(symbol_name_value_probes(), (1, 0));
+}
+
+#[test]
+fn visible_symbol_name_reads_reuse_a_large_working_set() {
+    let mut heap = crate::tagged::gc::TaggedHeap::new();
+    crate::tagged::gc::set_tagged_heap(&mut heap);
+    let symbols: Vec<_> = (0..1024)
+        .map(|i| {
+            let spelling = format!("visible-name-replacement-{i}");
+            let symbol = intern_uninterned(&spelling);
+            if i % 2 == 0 {
+                materialize_symbol_name_value(symbol);
+            }
+            (symbol, spelling)
+        })
+        .collect();
+    for pass in 0..2 {
+        reset_symbol_name_value_probes();
+        for (symbol, spelling) in &symbols {
+            assert_eq!(
+                resolve_lisp_visible_symbol_name(*symbol)
+                    .text()
+                    .as_utf8_str(),
+                Some(spelling.as_str())
+            );
+        }
+        if pass == 1 {
+            assert_eq!(
+                symbol_name_value_probes(),
+                (0, 0),
+                "a warmed scan must not thrash a fixed number of cache slots"
+            );
+        }
+    }
+}
+
 #[test]
 fn visible_symbol_name_reads_follow_heap_switch_and_drop() {
     let mut first_heap = Box::new(crate::tagged::gc::TaggedHeap::new());
@@ -226,6 +293,49 @@ fn visible_symbol_name_reads_follow_heap_switch_and_drop() {
     ));
 }
 
+#[test]
+fn visible_symbol_name_reads_survive_thread_cache_destruction() {
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicBool;
+
+    struct ReadNameOnDrop {
+        symbol: SymId,
+        checked: Arc<AtomicBool>,
+    }
+    impl Drop for ReadNameOnDrop {
+        fn drop(&mut self) {
+            assert_eq!(
+                resolve_lisp_visible_symbol_name(self.symbol)
+                    .text()
+                    .as_utf8_str(),
+                Some("visible-name-thread-exit-probe")
+            );
+            self.checked.store(true, Ordering::Relaxed);
+        }
+    }
+    thread_local! {
+        static READ_ON_DROP: RefCell<Option<ReadNameOnDrop>> = const { RefCell::new(None) };
+    }
+
+    let checked = Arc::new(AtomicBool::new(false));
+    let on_thread = Arc::clone(&checked);
+    std::thread::spawn(move || {
+        let symbol = intern_uninterned("visible-name-thread-exit-probe");
+        // TLS destructors run in reverse initialization order. Register the
+        // diagnostic first so its read runs after the name cache is destroyed.
+        READ_ON_DROP.with(|slot| {
+            *slot.borrow_mut() = Some(ReadNameOnDrop {
+                symbol,
+                checked: on_thread,
+            });
+        });
+        std::hint::black_box(resolve_lisp_visible_symbol_name(symbol));
+    })
+    .join()
+    .unwrap();
+    assert!(checked.load(Ordering::Relaxed));
+}
+
 #[test]
 fn visible_symbol_name_reads_preserve_identity_after_unintern_and_restore() {
     let mut heap = crate::tagged::gc::TaggedHeap::new();