fix performance test

Author: CppCXY

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

@@ -1211,8 +1211,10 @@ pub fn exec_tailcall(
                 return Err(vm.error("not a c function".to_string()));
             };
 
-            // Set up arguments in a temporary stack space
-            let call_base = vm.register_stack.len();
+            // CRITICAL FIX: Use current frame's base for C function call
+            // This avoids growing register_stack infinitely on repeated tail calls
+            // The current frame's stack space is being reused since this is a tail call
+            let call_base = base;
             vm.ensure_stack_capacity(call_base + args_len + 1);
 
             vm.register_stack[call_base] = func;

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

@@ -306,17 +306,19 @@ pub fn exec_tforcall(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -
             let code_ptr = func_ref.chunk.code.as_ptr();
             let constants_ptr = func_ref.chunk.constants.as_ptr();
 
-            let call_base = vm.register_stack.len();
+            // CRITICAL FIX: Use proper call base relative to current frame
+            // Arguments are already at base_ptr + a + 4 and base_ptr + a + 5 (state, control)
+            // New frame base should be at base_ptr + a + 4 where we placed the first arg
+            let call_base = base_ptr + a + 4;
             vm.ensure_stack_capacity(call_base + max_stack_size);
 
-            // Initialize registers
-            for i in 0..max_stack_size {
+            // Initialize registers beyond arguments
+            for i in 2..max_stack_size {
                 vm.register_stack[call_base + i] = LuaValue::nil();
             }
 
-            // Copy arguments
-            vm.register_stack[call_base] = state;
-            vm.register_stack[call_base + 1] = control;
+            // Arguments are already in place (state at +0, control at +1)
+            // No need to copy them again
 
             // Create new frame with correct nresults type
             let nresults = (c + 1) as i16;
@@ -325,9 +327,9 @@ pub fn exec_tforcall(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -
                 code_ptr,
                 constants_ptr,
                 call_base,
-                max_stack_size, // top = max_stack_size (we initialized this many registers)
-                a + 3,          // result goes to R[A+3]
-                nresults,       // expecting c+1 results
+                2,     // top = 2 (we have 2 arguments)
+                a + 3, // result goes to R[A+3]
+                nresults, // expecting c+1 results
             );
 
             vm.push_frame(new_frame);

crates/luars/src/lua_vm/mod.rs

@@ -1802,8 +1802,24 @@ impl LuaVM {
                 let code_ptr = func_ref.chunk.code.as_ptr();
                 let constants_ptr = func_ref.chunk.constants.as_ptr();
 
-                // Allocate registers in global stack
-                let new_base = self.register_stack.len();
+                // CRITICAL FIX: Calculate new base relative to current frame
+                // This prevents register_stack from growing indefinitely
+                let new_base = if self.frame_count > 0 {
+                    let current_frame = &self.frames[self.frame_count - 1];
+                    let caller_base = current_frame.base_ptr;
+                    let caller_max_stack =
+                        if let Some(caller_func_id) = current_frame.function_value.as_function_id() {
+                            self.object_pool
+                                .get_function(caller_func_id)
+                                .map(|f| f.chunk.max_stack_size)
+                                .unwrap_or(256)
+                        } else {
+                            256
+                        };
+                    caller_base + caller_max_stack
+                } else {
+                    0
+                };
                 self.ensure_stack_capacity(new_base + max_stack_size);
 
                 // Copy arguments to new frame's registers
@@ -1841,7 +1857,24 @@ impl LuaVM {
                 let cf = metamethod.as_cfunction().unwrap();
                 // Create temporary frame for CFunction
                 let arg_count = args.len() + 1; // +1 for function itself
-                let new_base = self.register_stack.len();
+                
+                // CRITICAL FIX: Calculate new base relative to current frame
+                let new_base = if self.frame_count > 0 {
+                    let current_frame = &self.frames[self.frame_count - 1];
+                    let caller_base = current_frame.base_ptr;
+                    let caller_max_stack =
+                        if let Some(caller_func_id) = current_frame.function_value.as_function_id() {
+                            self.object_pool
+                                .get_function(caller_func_id)
+                                .map(|f| f.chunk.max_stack_size)
+                                .unwrap_or(256)
+                        } else {
+                            256
+                        };
+                    caller_base + caller_max_stack
+                } else {
+                    0
+                };
                 self.ensure_stack_capacity(new_base + arg_count);
 
                 self.register_stack[new_base] = LuaValue::cfunction(cf);
@@ -2196,15 +2229,29 @@ impl LuaVM {
                         // Normal return - pop boundary frame and get return values
                         self.pop_frame_discard();
                         let result = std::mem::take(&mut self.return_values);
+                        
+                        // Clear the stack region used by this call to release references
+                        // This prevents GC from scanning stale objects after dofile/pcall
+                        for i in new_base..(new_base + max_stack_size) {
+                            if i < self.register_stack.len() {
+                                self.register_stack[i] = LuaValue::nil();
+                            }
+                        }
+                        
                         Ok(result)
                     }
                     Err(LuaError::Yield) => {
                         // Yield - frames stay for resume
                         Err(LuaError::Yield)
                     }
                     Err(e) => {
-                        // Error - pop boundary frame
+                        // Error - pop boundary frame and clear stack region
                         self.pop_frame_discard();
+                        for i in new_base..(new_base + max_stack_size) {
+                            if i < self.register_stack.len() {
+                                self.register_stack[i] = LuaValue::nil();
+                            }
+                        }
                         Err(e)
                     }
                 }