feat: run gc per frame

discord9 · discord9 · commit 000aa85321b7 · 2022-10-11T17:46:10.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/stdlib/src/gc.rs b/stdlib/src/gc.rs
@@ -6,22 +6,25 @@ mod gc {
 
     #[pyfunction]
     fn collect(_args: FuncArgs, _vm: &VirtualMachine) -> i32 {
-        0
+        let ret: usize = rustpython_vm::object::gc::collect().into();
+        ret as i32
     }
 
     #[pyfunction]
     fn isenabled(_args: FuncArgs, _vm: &VirtualMachine) -> bool {
-        false
+        rustpython_vm::object::gc::isenabled()
     }
 
     #[pyfunction]
     fn enable(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error("".to_owned()))
+        rustpython_vm::object::gc::enable();
+        Ok(vm.new_pyobj(true))
     }
 
     #[pyfunction]
     fn disable(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error("".to_owned()))
+        rustpython_vm::object::gc::disable();
+        Ok(vm.new_pyobj(true))
     }
 
     #[pyfunction]
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -1,4 +1,6 @@
 use crate::common::{boxvec::BoxVec, lock::PyMutex};
+#[cfg(feature = "gc")]
+use crate::object::gc::GLOBAL_COLLECTOR;
 use crate::{
     builtins::{
         asyncgenerator::PyAsyncGenWrappedValue,
@@ -349,6 +351,18 @@ impl ExecutingFrame<'_> {
             self.update_lasti(|i| *i += 1);
             let instr = &instrs[idx];
             let result = self.execute_instruction(instr, vm);
+            if matches!(instr, &bytecode::Instruction::ReturnValue) {
+                // only do gc if after certain instruction(to be decided), so to avoid strange bugs?
+                // it seems ReturnValue is safe enough & frequent enough to do gc() after execute it?
+                // &bytecode::Instruction::ReturnValue | &bytecode::Instruction::StoreLocal(..)
+                #[cfg(feature = "gc")]
+                {
+                    #[cfg(feature = "threading")]
+                    GLOBAL_COLLECTOR.gc();
+                    #[cfg(not(feature = "threading"))]
+                    GLOBAL_COLLECTOR.with(|v| v.gc());
+                }
+            }
             match result {
                 Ok(None) => continue,
                 Ok(Some(value)) => {
