update

Author: CppCXY

crates/luars/src/gc/mod.rs

@@ -158,12 +158,12 @@ impl GC {
             total_bytes: 0,
             state: GcState::Pause,
             current_white: 0,
-            gc_kind: GcKind::Generational, // Default to generational mode like Lua 5.4
+            gc_kind: GcKind::Generational, // Use generational mode like Lua 5.4
             sweep_index: 0,
             propagate_work: 0,
-            gc_pause: 200,      // Like Lua: 200 = wait until memory doubles
-            gen_minor_mul: 25,  // Minor GC when memory grows 25%
-            gen_major_mul: 100, // Major GC when memory grows 100% since last major
+            gc_pause: 200,
+            gen_minor_mul: 20,  // Minor GC when memory grows 20%
+            gen_major_mul: 50,  // Major GC when memory grows 50% (降低以更频繁触发major GC清除weak tables)
             last_atomic: 0,
             gc_estimate: 0,
             young_list: Vec::with_capacity(1024),
@@ -299,63 +299,36 @@ impl GC {
         }
     }
 
-    /// Incremental GC step - original incremental mode
+    /// Incremental GC step - complete one full cycle
     fn inc_step(&mut self, roots: &[LuaValue], pool: &mut ObjectPool) {
-        const WORK_PER_STEP: usize = 4096;
-        let mut work = 0;
-
-        // State machine for incremental GC
-        loop {
-            match self.state {
-                GcState::Pause => {
-                    // Start new cycle: mark roots and transition to propagate
-                    self.start_cycle(roots, pool);
-                    self.state = GcState::Propagate;
-                    work += 100; // Small fixed cost
-                }
-
-                GcState::Propagate => {
-                    // Incremental marking: process some gray objects
-                    let marked = self.propagate_step(pool, WORK_PER_STEP - work);
-                    work += marked;
-
-                    if self.gray.is_empty() && self.grayagain.is_empty() {
-                        // All marking done, go to atomic phase
-                        self.state = GcState::Atomic;
-                    }
-                }
-
-                GcState::Atomic => {
-                    // Atomic phase - must finish marking (like Lua's atomic)
-                    // Process any grayagain objects
-                    while let Some(gc_id) = self.grayagain.pop() {
-                        self.mark_one(gc_id, pool);
-                    }
-                    // Clear weak table entries before sweep
-                    self.clear_weak_tables(pool);
-                    // Start sweep
-                    self.sweep_index = 0;
-                    self.state = GcState::Sweep;
-                    work += 50;
-                }
-
-                GcState::Sweep => {
-                    // Complete sweep in one step (pools are iterated directly)
-                    let swept = self.sweep_step(pool, WORK_PER_STEP - work);
-                    work += swept;
-                    // sweep_step handles state transition and finish_cycle
-                    break;
-                }
-            }
-
-            // Check if we've done enough work for this step
-            if work >= WORK_PER_STEP {
-                break;
-            }
+        // Pause -> Start cycle and mark roots
+        if self.state == GcState::Pause {
+            self.start_cycle(roots, pool);
+            self.state = GcState::Propagate;
+        }
+        
+        // Propagate -> Mark all gray objects
+        if self.state == GcState::Propagate {
+            while let Some(gc_id) = self.gray.pop() {
+                self.mark_one(gc_id, pool);
+            }
+            self.state = GcState::Atomic;
+        }
+        
+        // Atomic -> Process grayagain and clear weak tables
+        if self.state == GcState::Atomic {
+            while let Some(gc_id) = self.grayagain.pop() {
+                self.mark_one(gc_id, pool);
+            }
+            self.clear_weak_tables(pool);
+            self.sweep_index = 0;
+            self.state = GcState::Sweep;
+        }
+        
+        // Sweep -> Clean up dead objects
+        if self.state == GcState::Sweep {
+            self.sweep_step(pool, usize::MAX);
         }
-
-        // Reduce debt by work done (convert work to "bytes paid off")
-        self.gc_debt -= (work as isize) * 2;
     }
 
     /// Start a new GC cycle - mark roots and build gray list
@@ -664,6 +637,7 @@ impl GC {
         }
         for id in dead_tables {
             pool.tables.free(id);
+            self.total_bytes = self.total_bytes.saturating_sub(256);
             self.record_deallocation(256);
             collected += 1;
         }
@@ -677,6 +651,7 @@ impl GC {
         }
         for id in dead_funcs {
             pool.functions.free(id);
+            self.total_bytes = self.total_bytes.saturating_sub(128);
             self.record_deallocation(128);
             collected += 1;
         }
@@ -703,6 +678,7 @@ impl GC {
         }
         for id in dead_strings {
             pool.strings.free(id);
+            self.total_bytes = self.total_bytes.saturating_sub(64);
             self.record_deallocation(64);
             collected += 1;
         }
@@ -1372,14 +1348,14 @@ impl GC {
             if let Some(mt_id) = table.data.get_metatable().and_then(|v| v.as_table_id()) {
                 if let Some(mt) = pool.tables.get(mt_id.0) {
                     // Look for __mode key in metatable
-                    // We need to find the string "__mode" in the metatable
                     let mode = self.get_weak_mode(mt, pool);
                     if let Some((weak_keys, weak_values)) = mode {
                         // Collect keys to remove
                         let mut keys_to_remove = Vec::new();
                         for (key, value) in table.data.iter_all() {
                             let key_dead = weak_keys && self.is_value_dead(&key, pool);
                             let value_dead = weak_values && self.is_value_dead(&value, pool);
+                            
                             if key_dead || value_dead {
                                 keys_to_remove.push(key);
                             }

crates/luars/src/lua_vm/execute/mod.rs

@@ -86,6 +86,20 @@ pub fn luavm_execute(vm: &mut LuaVM) -> LuaResult<LuaValue> {
 
         let opcode = get_op!(instr);
 
+        // CRITICAL: Implement Lua 5.4's top management (lvm.c line 1183)
+        // lua_assert(isIT(i) || (cast_void(L->top.p = base), 1));
+        // For non-IT instructions, reset top to base to prevent temporary values
+        // from being kept alive by GC.
+        // In Lua 5.4: base = ci->func.p + 1 (first register of current function)
+        // In our VM: base_ptr is already the first register position
+        // So we set top = 0 (relative to base_ptr), meaning no registers are "active"
+        // for GC purposes. IT instructions will set top correctly when needed.
+        unsafe {
+            if !opcode.uses_top() {
+                (*frame_ptr).top = 0;
+            }
+        }
+        
         match opcode {
             // ============ HOT PATH: Inline simple instructions (< 10 lines) ============
 

crates/luars/src/lua_vm/mod.rs

@@ -1722,7 +1722,9 @@ impl LuaVM {
     pub fn create_string_owned(&mut self, s: String) -> LuaValue {
         let len = s.len();
         let id = self.object_pool.create_string_owned(s);
-        self.gc_debt_local += (32 + len) as isize;
+        let size = (32 + len) as isize;
+        self.gc_debt_local += size;
+        self.gc.total_bytes = self.gc.total_bytes.saturating_add(size as usize);
         LuaValue::string(id)
     }
 
@@ -1807,6 +1809,7 @@ impl LuaVM {
     pub fn create_table(&mut self, array_size: usize, hash_size: usize) -> LuaValue {
         let id = self.object_pool.create_table(array_size, hash_size);
         self.gc_debt_local += 256;
+        self.gc.total_bytes = self.gc.total_bytes.saturating_add(256);
         LuaValue::table(id)
     }
 
@@ -2113,12 +2116,9 @@ impl LuaVM {
     /// OPTIMIZATION: Fast path is inlined, slow path is separate function
     #[inline(always)]
     fn check_gc(&mut self) {
-        // Fast path: check if gc_debt_local > threshold
-        // Use a larger threshold to reduce GC frequency
-        // 1MB threshold = about 16000 small object allocations before GC
-        // The incremental GC will catch up during collection anyway
-        const GC_THRESHOLD: isize = 1024 * 1024;
-        if self.gc_debt_local <= GC_THRESHOLD {
+        // Fast path: check if gc_debt_local > 0
+        // Once debt becomes positive, trigger GC step
+        if self.gc_debt_local <= 0 {
             return;
         }
         // Slow path: actual GC work
@@ -2164,7 +2164,11 @@ impl LuaVM {
             let top = frame.top as usize;
             for i in 0..top {
                 if base_ptr + i < self.register_stack.len() {
-                    self.gc_roots_buffer.push(self.register_stack[base_ptr + i]);
+                    let value = self.register_stack[base_ptr + i];
+                    // Skip nil values - they don't need to be roots
+                    if !value.is_nil() {
+                        self.gc_roots_buffer.push(value);
+                    }
                 }
             }
         }

crates/luars/src/lua_vm/opcode/mod.rs

@@ -160,6 +160,30 @@ impl OpCode {
         unsafe { std::mem::transmute(byte) }
     }
 
+    /// Check if instruction uses "top" (IT mode - In Top)
+    /// These instructions depend on the value of 'top' from previous instruction
+    /// For all other instructions, top should be reset to base + nactvar
+    #[inline(always)]
+    /// Check if this opcode uses "top" from previous instruction (isIT in Lua 5.4)
+    /// These instructions expect top to be set correctly by previous instruction.
+    /// For all other instructions, Lua 5.4 resets top = base before execution.
+    /// 
+    /// From Lua 5.4 lopcodes.c:
+    /// - CALL: IT=1 (uses top for vararg count)
+    /// - TAILCALL: IT=1
+    /// - RETURN: IT=1 (uses top for return count)
+    /// - SETLIST: IT=1 (uses top for list size)
+    /// - VARARGPREP: IT=1 (sets up varargs)
+    /// 
+    /// Note: RETURN0, RETURN1, Vararg, Concat are NOT IT instructions in Lua 5.4!
+    pub fn uses_top(self) -> bool {
+        use OpCode::*;
+        matches!(
+            self,
+            Call | TailCall | Return | SetList | VarargPrep
+        )
+    }
+
     /// Get the instruction format mode for this opcode
     /// Based on Lua 5.4 lopcodes.c luaP_opmodes table
     pub fn get_mode(self) -> OpMode {

crates/luars/src/stdlib/basic.rs

@@ -58,6 +58,7 @@ fn lua_print(vm: &mut LuaVM) -> LuaResult<MultiValue> {
     } else {
         println!();
     }
+    println!(); // Extra blank line for visibility
 
     Ok(MultiValue::empty())
 }