Add PyDict freelist and exact-type guard for freelist push

youknowone · youknowone · commit a57152c5f280 · 2026-03-04T04:33:20.000+09:00
Add thread-local freelist for PyDict (max 80 entries).

Add heaptype check in default_dealloc to prevent subclass instances
from entering the freelist. Subclass objects have a different Python
type than the base type, so reusing them would return objects with
the wrong __class__.

Skip PyTuple freelist: structseq types (stat_result, struct_time)
are static subtypes sharing the same Rust payload, making type-safe
reuse impractical with heaptype check alone.
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
@@ -26,6 +26,8 @@ use crate::{
     vm::VirtualMachine,
 };
 use alloc::fmt;
+use core::cell::Cell;
+use core::ptr::NonNull;
 use rustpython_common::lock::PyMutex;
 use rustpython_common::wtf8::Wtf8Buf;
 
@@ -60,11 +62,44 @@ impl fmt::Debug for PyDict {
     }
 }
 
+const PYDICT_MAXFREELIST: usize = 80;
+
+thread_local! {
+    static DICT_FREELIST: Cell<Vec<*mut PyObject>> = const { Cell::new(Vec::new()) };
+}
+
 impl PyPayload for PyDict {
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.dict_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        DICT_FREELIST.with(|fl| {
+            let mut list = fl.take();
+            let stored = if list.len() < PYDICT_MAXFREELIST {
+                list.push(obj);
+                true
+            } else {
+                false
+            };
+            fl.set(list);
+            stored
+        })
+    }
+
+    #[inline]
+    unsafe fn freelist_pop() -> Option<NonNull<PyObject>> {
+        DICT_FREELIST.with(|fl| {
+            let mut list = fl.take();
+            let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+            fl.set(list);
+            result
+        })
+    }
 }
 
 impl PyDict {
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
@@ -53,6 +53,9 @@ unsafe impl Traverse for PyTuple {
     }
 }
 
+// No freelist for PyTuple: structseq types (stat_result, struct_time, etc.)
+// are static subtypes sharing the same Rust payload, making type-safe reuse
+// impractical without a type-pointer comparison at push time.
 impl PyPayload for PyTuple {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
@@ -193,7 +193,14 @@ pub(super) unsafe fn default_dealloc<T: PyPayload>(obj: *mut PyObject) {
     }
 
     // Try to store in freelist for reuse; otherwise deallocate.
-    if !unsafe { T::freelist_push(obj) } {
+    // Only exact types (not heaptype subclasses) go into the freelist,
+    // because the pop site assumes the cached typ matches the base type.
+    let pushed = if T::HAS_FREELIST && obj_ref.class().heaptype_ext.is_none() {
+        unsafe { T::freelist_push(obj) }
+    } else {
+        false
+    };
+    if !pushed {
         drop(unsafe { Box::from_raw(obj as *mut PyInner<T>) });
     }
 

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,9 @@ unsafe impl Traverse for PyTuple {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
	`56`	`+// No freelist for PyTuple: structseq types (stat_result, struct_time, etc.)`
	`57`	`+// are static subtypes sharing the same Rust payload, making type-safe reuse`
	`58`	`+// impractical without a type-pointer comparison at push time.`
`56`	`59`	`impl PyPayload for PyTuple {`
`57`	`60`	`#[inline]`
`58`	`61`	`fn class(ctx: &Context) -> &'static Py<PyType> {`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,14 @@ pub(super) unsafe fn default_dealloc<T: PyPayload>(obj: *mut PyObject) {`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`// Try to store in freelist for reuse; otherwise deallocate.`
`196`		`- if !unsafe { T::freelist_push(obj) } {`
	`196`	`+ // Only exact types (not heaptype subclasses) go into the freelist,`
	`197`	`+ // because the pop site assumes the cached typ matches the base type.`
	`198`	`+ let pushed = if T::HAS_FREELIST && obj_ref.class().heaptype_ext.is_none() {`
	`199`	`+ unsafe { T::freelist_push(obj) }`
	`200`	`+ } else {`
	`201`	`+ false`
	`202`	`+ };`
	`203`	`+ if !pushed {`
`197`	`204`	`drop(unsafe { Box::from_raw(obj as *mut PyInner<T>) });`
`198`	`205`	`}`
`199`	`206`