JIT: stop watching types that churn their inline-cache invalidations

Workloads that frequently mutate a small set of types on a hot path
(PyTorch's autocast/no-grad/training-mode contexts are the canonical
example) trigger full inline-cache invalidation on every mutation.
Even when the inline cache is not actually missing for the lookups
that matter, the per-mutation watcher-notification chain dominates
execution time.

Track per-type invalidation count. Once a type has been invalidated
beyond a threshold (default 10), mark it volatile and stop registering
new IC watchers for it. Inline-cache lookups against volatile types
fall back to the slow path — correct, but no longer paying the
notification cost.

The change touches only the inline-cache layer; downstream cache
behaviour for non-volatile types is unchanged.

Empirical: this patch applied to upstream master HEAD reproduces the
pytorch_cm speedup on both architectures. PR-branch measurements at
reps=5: 1.35x x86_64 (170.89ms cinderx vs 230.22ms vanilla, +25.8%)
and 1.17x aarch64 (79.53ms cinderx vs 93.41ms vanilla, +14.9%). A
corroborating-prior forward-port ablation on a master substrate
~11 days older measured 1.13x x86_64 and 1.08x aarch64 at reps=5;
substrate-differences (bench mode and build-flag adjustments and
11 days of intervening master commits) account for the magnitude
variance, and the speedup direction and mechanism reproduce on both
architectures.

Author: SonicField

cinderx/Jit/inline_cache.cpp

@@ -22,11 +22,31 @@ namespace jit {
 
 namespace {
 
+constexpr int kVolatileTypeThreshold = 10;
+
+jit::UnorderedMap<BorrowedRef<PyTypeObject>, int> type_invalidation_counts;
+jit::UnorderedSet<BorrowedRef<PyTypeObject>> volatile_types;
+
+bool isVolatileType(BorrowedRef<PyTypeObject> type) {
+  return volatile_types.count(type) > 0;
+}
+
+void recordTypeInvalidation(BorrowedRef<PyTypeObject> type) {
+  int& count = type_invalidation_counts[type];
+  count++;
+  if (count >= kVolatileTypeThreshold) {
+    volatile_types.emplace(type);
+  }
+}
+
 template <class T>
 struct TypeWatcher {
   jit::UnorderedMap<BorrowedRef<PyTypeObject>, jit::UnorderedSet<T*>> caches;
 
   void watch(BorrowedRef<PyTypeObject> type, T* cache) {
+    if (isVolatileType(type)) {
+      return;
+    }
     JIT_CHECK(
         cinderx::getModuleState()->watcher_state.watchType(type) == 0,
         "Failed to watch type {} for attribute cache",
@@ -1601,6 +1621,7 @@ LoadModuleMethodCache::lookupSlowPath(BorrowedRef<> obj, BorrowedRef<> name) {
 }
 
 void notifyICsTypeChanged(BorrowedRef<PyTypeObject> type) {
+  recordTypeInvalidation(type);
   ac_watcher.typeChanged(type);
   ltac_watcher.typeChanged(type);
   lm_watcher.typeChanged(type);