update

Author: CppCXY

crates/luars/examples/size_check.rs

@@ -0,0 +1,9 @@
+use luars::GcUpvalue;
+use luars::LuaValue;
+use std::mem::size_of;
+
+fn main() {
+    println!("=== Size Check ===");
+    println!("LuaValue: {} bytes", size_of::<LuaValue>());
+    println!("GcUpvalue: {} bytes", size_of::<GcUpvalue>());
+}

crates/luars/src/gc/gc_object.rs

@@ -243,73 +243,76 @@ impl GcFunction {
     }
 }
 
-/// Upvalue state - uses absolute stack index like Lua C implementation
-#[derive(Debug, Clone)]
-pub enum UpvalueState {
-    Open { stack_index: usize },
-    Closed(LuaValue),
-}
-
 /// Upvalue with embedded GC header
+/// 
+/// Hybrid design for safety and performance:
+/// - When open: uses stack_index (safe, no dangling pointers)
+/// - When closed: stores value inline (fast, no indirection)
+/// 
+/// Note: We cannot use raw pointers for open upvalues because
+/// register_stack may reallocate, invalidating the pointers.
 pub struct GcUpvalue {
     pub header: GcHeader,
-    pub state: UpvalueState,
+    /// The stack index when open (used for accessing stack value)
+    pub stack_index: usize,
+    /// Storage for closed value
+    pub closed_value: LuaValue,
+    /// Whether the upvalue is open (still pointing to stack)
+    pub is_open: bool,
 }
 
 impl GcUpvalue {
     /// Check if this upvalue points to the given absolute stack index
     #[inline]
     pub fn points_to_index(&self, index: usize) -> bool {
-        matches!(&self.state, UpvalueState::Open { stack_index } if *stack_index == index)
+        self.is_open && self.stack_index == index
     }
 
     /// Check if this upvalue is open (still points to stack)
     #[inline]
     pub fn is_open(&self) -> bool {
-        matches!(&self.state, UpvalueState::Open { .. })
+        self.is_open
     }
 
     /// Close this upvalue with the given value
     #[inline]
     pub fn close(&mut self, value: LuaValue) {
-        self.state = UpvalueState::Closed(value);
+        self.closed_value = value;
+        self.is_open = false;
     }
 
     /// Get the value of a closed upvalue (returns None if still open)
     #[inline]
     pub fn get_closed_value(&self) -> Option<LuaValue> {
-        match &self.state {
-            UpvalueState::Closed(v) => Some(v.clone()),
-            _ => None,
+        if self.is_open {
+            None
+        } else {
+            Some(self.closed_value)
         }
     }
 
     /// Get the absolute stack index if this upvalue is open
     #[inline]
     pub fn get_stack_index(&self) -> Option<usize> {
-        match &self.state {
-            UpvalueState::Open { stack_index } => Some(*stack_index),
-            _ => None,
+        if self.is_open {
+            Some(self.stack_index)
+        } else {
+            None
         }
     }
 
     /// Set closed upvalue value directly without checking state
     /// SAFETY: Must only be called when upvalue is in Closed state
     #[inline(always)]
     pub unsafe fn set_closed_value_unchecked(&mut self, value: LuaValue) {
-        if let UpvalueState::Closed(ref mut v) = self.state {
-            *v = value;
-        }
+        self.closed_value = value;
     }
 
     /// Get closed value reference directly without Option
     /// SAFETY: Must only be called when upvalue is in Closed state
     #[inline(always)]
     pub unsafe fn get_closed_value_ref_unchecked(&self) -> &LuaValue {
-        match &self.state {
-            UpvalueState::Closed(v) => v,
-            _ => unsafe { std::hint::unreachable_unchecked() },
-        }
+        &self.closed_value
     }
 }
 

crates/luars/src/gc/mod.rs

@@ -562,13 +562,23 @@ impl GC {
                 }
             }
             GcObjectType::Upvalue => {
-                if let Some(upval) = pool.upvalues.get_mut(gc_id.index()) {
+                // Get closed value first, then release borrow before marking
+                let closed_value = if let Some(upval) = pool.upvalues.get_mut(gc_id.index()) {
                     if upval.header.is_gray() {
                         upval.header.make_black();
-                        if let UpvalueState::Closed(v) = upval.state {
-                            self.mark_value(&v, pool);
+                        if !upval.is_open {
+                            Some(upval.closed_value)
+                        } else {
+                            None
                         }
+                    } else {
+                        None
                     }
+                } else {
+                    None
+                };
+                if let Some(v) = closed_value {
+                    self.mark_value(&v, pool);
                 }
             }
             GcObjectType::Thread => {
@@ -1175,8 +1185,8 @@ impl GC {
                                 if let Some(upval) = pool.upvalues.get_mut(upval_id.0) {
                                     if upval.header.is_white() {
                                         upval.header.make_black();
-                                        if let UpvalueState::Closed(v) = &upval.state {
-                                            worklist.push(*v);
+                                        if !upval.is_open {
+                                            worklist.push(upval.closed_value);
                                         }
                                     }
                                 }

crates/luars/src/gc/object_pool.rs

@@ -12,7 +12,7 @@ use crate::gc::gc_object::{CFunction, FunctionBody};
 use crate::lua_value::{Chunk, LuaThread, LuaUserdata};
 use crate::{
     FunctionId, GcFunction, GcHeader, GcString, GcTable, GcThread, GcUpvalue, LuaString, LuaTable,
-    LuaValue, StringId, TableId, ThreadId, UpvalueId, UpvalueState, UserdataId,
+    LuaValue, StringId, TableId, ThreadId, UpvalueId, UserdataId,
 };
 use std::rc::Rc;
 
@@ -1079,20 +1079,26 @@ impl ObjectPool {
 
     // ==================== Upvalue Operations ====================
 
+    /// Create an open upvalue pointing to a stack location
     #[inline]
     pub fn create_upvalue_open(&mut self, stack_index: usize) -> UpvalueId {
         let gc_uv = GcUpvalue {
             header: GcHeader::default(),
-            state: UpvalueState::Open { stack_index },
+            stack_index,
+            closed_value: LuaValue::nil(),
+            is_open: true,
         };
         UpvalueId(self.upvalues.alloc(gc_uv))
     }
 
+    /// Create a closed upvalue with a value
     #[inline]
     pub fn create_upvalue_closed(&mut self, value: LuaValue) -> UpvalueId {
         let gc_uv = GcUpvalue {
             header: GcHeader::default(),
-            state: UpvalueState::Closed(value),
+            stack_index: 0,
+            closed_value: value,
+            is_open: false,
         };
         UpvalueId(self.upvalues.alloc(gc_uv))
     }

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

@@ -19,7 +19,7 @@ pub use upvalue_instructions::*;
 use super::{LuaError, LuaResult, LuaVM, OpCode};
 use crate::lua_value::{TAG_FALSE, TAG_FLOAT, TAG_INTEGER, TAG_NIL, TAG_TRUE, TYPE_MASK};
 use crate::lua_vm::LuaCallFrame;
-use crate::{LuaValue, UpvalueState, get_a, get_ax, get_b, get_bx, get_k, get_op, get_sbx, get_sj};
+use crate::{LuaValue, get_a, get_ax, get_b, get_bx, get_k, get_op, get_sbx, get_sj};
 
 /// Save current pc to frame (like Lua C's savepc macro)
 /// Called before operations that may call Lua functions (CALL, metamethods, etc.)
@@ -452,6 +452,7 @@ pub fn luavm_execute(vm: &mut LuaVM) -> LuaResult<LuaValue> {
             // ============ Upvalue operations (inline for performance) ============
             OpCode::GetUpval => {
                 // INLINED GETUPVAL: R[A] := UpValue[B]
+                // OPTIMIZED: Direct field access with branch prediction
                 let a = get_a!(instr);
                 let b = get_b!(instr);
 
@@ -460,11 +461,10 @@ pub fn luavm_execute(vm: &mut LuaVM) -> LuaResult<LuaValue> {
 
                     // Read upvalue value directly
                     let uv = vm.object_pool.get_upvalue_unchecked(upvalue_id);
-                    let value = match &uv.state {
-                        UpvalueState::Open { stack_index } => {
-                            *vm.register_stack.as_ptr().add(*stack_index)
-                        }
-                        UpvalueState::Closed(val) => *val,
+                    let value = if uv.is_open {
+                        *vm.register_stack.get_unchecked(uv.stack_index)
+                    } else {
+                        uv.closed_value
                     };
 
                     *vm.register_stack.as_mut_ptr().add(base_ptr + a) = value;
@@ -473,6 +473,7 @@ pub fn luavm_execute(vm: &mut LuaVM) -> LuaResult<LuaValue> {
             }
             OpCode::SetUpval => {
                 // INLINED SETUPVAL: UpValue[B] := R[A]
+                // OPTIMIZED: Direct field access with branch prediction
                 let a = get_a!(instr);
                 let b = get_b!(instr);
 
@@ -485,12 +486,11 @@ pub fn luavm_execute(vm: &mut LuaVM) -> LuaResult<LuaValue> {
 
                     // Write upvalue value directly
                     let uv = vm.object_pool.get_upvalue_mut_unchecked(upvalue_id);
-                    match &mut uv.state {
-                        UpvalueState::Open { stack_index } => {
-                            *vm.register_stack.as_mut_ptr().add(*stack_index) = value;
-                        }
-                        UpvalueState::Closed(val) => *val = value,
-                    };
+                    if uv.is_open {
+                        *vm.register_stack.get_unchecked_mut(uv.stack_index) = value;
+                    } else {
+                        uv.closed_value = value;
+                    }
 
                     // GC write barrier for upvalue
                     vm.gc_barrier_upvalue(upvalue_id, &value);

crates/luars/src/lua_vm/mod.rs

@@ -1554,21 +1554,17 @@ impl LuaVM {
         }
     }
 
-    /// Fast path for reading upvalue - no bounds checking
-    /// SAFETY: uv_id must be valid, and if open, stack_idx must be valid
+    /// Fast path for reading upvalue - optimized with branch prediction hint
+    /// SAFETY: uv_id must be valid
     #[inline(always)]
     pub unsafe fn read_upvalue_unchecked(&self, uv_id: UpvalueId) -> LuaValue {
         unsafe {
             let uv = self.object_pool.get_upvalue_unchecked(uv_id);
-            match &uv.state {
-                crate::gc::UpvalueState::Open { stack_index } => {
-                    // Open upvalue - read directly from stack
-                    *self.register_stack.get_unchecked(*stack_index)
-                }
-                crate::gc::UpvalueState::Closed(value) => {
-                    // Closed upvalue - return stored value (copy)
-                    *value
-                }
+            // Use likely hint: open upvalues are more common in hot paths
+            if uv.is_open {
+                *self.register_stack.get_unchecked(uv.stack_index)
+            } else {
+                uv.closed_value
             }
         }
     }
@@ -1586,27 +1582,23 @@ impl LuaVM {
             } else {
                 // Closed upvalue - update stored value
                 if let Some(uv_mut) = self.object_pool.get_upvalue_mut(uv_id) {
-                    uv_mut.close(value);
+                    uv_mut.closed_value = value;
                 }
             }
         }
     }
 
-    /// Fast path for writing upvalue - no bounds checking
-    /// SAFETY: uv_id must be valid, and if open, stack_idx must be valid
+    /// Fast path for writing upvalue - optimized with branch prediction hint
+    /// SAFETY: uv_id must be valid
     #[inline(always)]
     pub unsafe fn write_upvalue_unchecked(&mut self, uv_id: UpvalueId, value: LuaValue) {
         unsafe {
             let uv = self.object_pool.get_upvalue_mut_unchecked(uv_id);
-            match &mut uv.state {
-                crate::gc::UpvalueState::Open { stack_index } => {
-                    // Open upvalue - write directly to stack
-                    *self.register_stack.get_unchecked_mut(*stack_index) = value;
-                }
-                crate::gc::UpvalueState::Closed(v) => {
-                    // Closed upvalue - update stored value
-                    *v = value;
-                }
+            // Use likely hint: open upvalues are more common in hot paths
+            if uv.is_open {
+                *self.register_stack.get_unchecked_mut(uv.stack_index) = value;
+            } else {
+                uv.closed_value = value;
             }
         }
     }