optimize

CppCXY · CppCXY · commit 1478e575118f · 2025-12-03T01:43:25.000+08:00
diff --git a/crates/luars/src/lua_value/lua_table.rs b/crates/luars/src/lua_value/lua_table.rs
@@ -87,21 +87,22 @@ impl LuaTable {
     }
 
     /// Hash function for LuaValue - optimized for speed
+    /// Uses identity hash for GC objects (string/table/function ID) and value hash for primitives
     #[inline(always)]
     fn hash_key(key: &LuaValue, size: usize) -> usize {
-        if size == 0 {
-            return 0;
-        }
-
-        // Use XOR of both words for good distribution
-        // This is faster than type-checking and works for all value types
-        let raw = key.primary ^ key.secondary;
-
-        // Simple but effective mixing (from FxHash)
-        let hash = raw.wrapping_mul(0x517cc1b727220a95);
+        // Combine primary and secondary for best distribution
+        // For strings: primary has tag|id, secondary is 0 -> hash of id
+        // For integers: primary has tag, secondary has value -> hash of value
+        // For floats: similar to integers
+        // XOR gives good mixing without branch
+        let raw = key.primary.wrapping_add(key.secondary);
+        
+        // Fibonacci hashing - excellent distribution for sequential IDs
+        // Golden ratio: 2^64 / phi ≈ 0x9e3779b97f4a7c15
+        let hash = raw.wrapping_mul(0x9e3779b97f4a7c15);
 
         // Fast modulo using bitmask (size is power of 2)
-        (hash as usize) & (size - 1)
+        (hash >> 32) as usize & (size - 1)
     }
 
     /// Find a node with the given key, returns Some(index) if found
diff --git a/crates/luars/src/lua_value/lua_value.rs b/crates/luars/src/lua_value/lua_value.rs
@@ -405,28 +405,30 @@ impl LuaValue {
     // ============ Equality ============
 
     /// Raw equality (no metamethods)
-    /// OPTIMIZED: For interned types (string/table/etc), primary contains ID - no secondary check needed
+    /// OPTIMIZED: Branchless comparison for common case, only branch for float NaN handling
     #[inline(always)]
     pub fn raw_equal(&self, other: &Self) -> bool {
-        // Fast path: if primary differs, they're not equal (different type or ID)
-        if self.primary != other.primary {
-            return false;
-        }
-        // Primary matches
-        // Only INTEGER and FLOAT store value in secondary
-        // INTEGER: primary is just TAG_INTEGER, value in secondary
-        // FLOAT: primary is just TAG_FLOAT, value bits in secondary + NaN handling
-        // All other types: ID or value encoded in primary, secondary unused or always 0
-        let tag = self.primary & TAG_MASK;
-        if tag == TAG_INTEGER {
-            self.secondary == other.secondary
-        } else if tag == TAG_FLOAT {
-            let a = f64::from_bits(self.secondary);
-            let b = f64::from_bits(other.secondary);
-            a == b
+        // Compare both primary and secondary
+        // This is branchless and correct for:
+        // - Strings/Tables/Functions: primary has tag|id, secondary is 0
+        // - Integers: primary is TAG_INTEGER, secondary has value
+        // - Booleans: primary is TAG_TRUE or TAG_FALSE, secondary is 0
+        // - Nil: primary is TAG_NIL, secondary is 0
+        //
+        // Special case: Float - IEEE 754 says NaN != NaN, but bit comparison would say equal
+        // We handle this with a single branch check
+        if self.primary == other.primary && self.secondary == other.secondary {
+            // Fast path: bits match
+            // Need to verify this isn't two NaNs comparing equal
+            if (self.primary & TAG_MASK) == TAG_FLOAT {
+                // For floats, use proper IEEE comparison
+                let a = f64::from_bits(self.secondary);
+                a == a // Returns false if NaN
+            } else {
+                true
+            }
         } else {
-            // String, Table, Function, etc - primary already contains unique ID
-            true
+            false
         }
     }
 
diff --git a/crates/luars/src/lua_vm/execute/table_instructions.rs b/crates/luars/src/lua_vm/execute/table_instructions.rs
@@ -75,21 +75,22 @@ pub fn exec_gettable(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame, b
         (table, key)
     };
 
-    // FAST PATH: Direct table access for common case (integer key, no metatable)
+    // FAST PATH: Direct table access for common case
     if let Some(table_id) = table_value.as_table_id() {
         // SAFETY: table_id is valid because it came from as_table_id()
         let lua_table = unsafe { vm.object_pool.get_table_unchecked(table_id) };
 
-        // Try integer key fast path first
-        if let Some(i) = key_value.as_integer() {
-            if let Some(val) = lua_table.get_int(i) {
-                unsafe { *vm.register_stack.get_unchecked_mut(*base_ptr + a) = val };
-                return Ok(());
-            }
-        }
+        // Check key type to choose optimal path
+        // Integer keys may be in array part, other keys are in hash part
+        let result = if let Some(i) = key_value.as_integer() {
+            // Integer key: try array first, then hash
+            lua_table.get_int(i).or_else(|| lua_table.get_from_hash(&key_value))
+        } else {
+            // Non-integer key: direct hash lookup (most common for string keys)
+            lua_table.get_from_hash(&key_value)
+        };
 
-        // Try hash lookup
-        if let Some(val) = lua_table.get_from_hash(&key_value) {
+        if let Some(val) = result {
             if !val.is_nil() {
                 unsafe { *vm.register_stack.get_unchecked_mut(*base_ptr + a) = val };
                 return Ok(());
@@ -259,44 +260,35 @@ pub fn exec_seti(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame, base_
 
 /// GETFIELD A B C
 /// R[A] := R[B][K[C]:string]
+/// OPTIMIZED: Uses cached constants_ptr for direct constant access
 #[inline(always)]
 pub fn exec_getfield(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame, base_ptr: &mut usize) -> LuaResult<()> {
     let a = Instruction::get_a(instr) as usize;
     let b = Instruction::get_b(instr) as usize;
     let c = Instruction::get_c(instr) as usize;
 
-    let func_value = unsafe { (*frame_ptr).function_value };
-
-    // Get key constant using new API
-    let Some(func_id) = func_value.as_function_id() else {
-        return Err(vm.error("Not a Lua function".to_string()));
-    };
-    let Some(func_ref) = vm.object_pool.get_function(func_id) else {
-        return Err(vm.error("Invalid function ID".to_string()));
-    };
-    let Some(key_value) = func_ref.chunk.constants.get(c).copied() else {
-        return Err(vm.error(format!("Invalid constant index: {}", c)));
-    };
-
-    let table_value = vm.register_stack[*base_ptr + b];
+    // FAST PATH: Direct constant access via cached pointer (like GETTABUP)
+    let key_value = unsafe { *(*frame_ptr).constants_ptr.add(c) };
+    let table_value = unsafe { *vm.register_stack.get_unchecked(*base_ptr + b) };
 
     // FAST PATH: Direct hash access for tables without metatable
     if let Some(table_id) = table_value.as_table_id() {
-        if let Some(table_ref) = vm.object_pool.get_table(table_id) {
-            // Use optimized hash-only lookup (GETFIELD always uses string keys, never integers)
-            if let Some(val) = table_ref.get_from_hash(&key_value) {
-                if !val.is_nil() {
-                    vm.register_stack[*base_ptr + a] = val;
-                    return Ok(());
-                }
-            }
+        // OPTIMIZED: Use unchecked table access
+        let table_ref = unsafe { vm.object_pool.get_table_unchecked(table_id) };
 
-            // Check if no metatable - can return nil directly
-            if table_ref.get_metatable().is_none() {
-                vm.register_stack[*base_ptr + a] = LuaValue::nil();
+        // GETFIELD always uses string keys - direct hash lookup
+        if let Some(val) = table_ref.get_from_hash(&key_value) {
+            if !val.is_nil() {
+                unsafe { *vm.register_stack.get_unchecked_mut(*base_ptr + a) = val };
                 return Ok(());
             }
         }
+
+        // Check if no metatable - can return nil directly
+        if table_ref.get_metatable().is_none() {
+            unsafe { *vm.register_stack.get_unchecked_mut(*base_ptr + a) = LuaValue::nil() };
+            return Ok(());
+        }
     }
 
     // Slow path: Use metamethod handling
@@ -306,61 +298,44 @@ pub fn exec_getfield(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame, b
 
     // IMPORTANT: Re-read base_ptr after metamethod call in case frames changed
     *base_ptr = unsafe { (*frame_ptr).base_ptr };
-    vm.register_stack[*base_ptr + a] = value;
+    unsafe { *vm.register_stack.get_unchecked_mut(*base_ptr + a) = value };
 
     Ok(())
 }
 
 /// SETFIELD A B C k
 /// R[A][K[B]:string] := RK(C)
+/// OPTIMIZED: Uses cached constants_ptr for direct constant access
 #[inline(always)]
 pub fn exec_setfield(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame, base_ptr: &mut usize) -> LuaResult<()> {
     let a = Instruction::get_a(instr) as usize;
     let b = Instruction::get_b(instr) as usize;
     let c = Instruction::get_c(instr) as usize;
     let k = Instruction::get_k(instr);
 
-    // CRITICAL: Read all values BEFORE any metamethod calls
-    // because metamethods can modify the register stack
+    // FAST PATH: Direct access via cached pointers
     let (table_value, key_value, set_value) = unsafe {
-        let func_value = (*frame_ptr).function_value;
-
-        // Get key constant using new API
-        let Some(func_id) = func_value.as_function_id() else {
-            return Err(vm.error("Not a Lua function".to_string()));
-        };
-        let Some(func_ref) = vm.object_pool.get_function(func_id) else {
-            return Err(vm.error("Invalid function ID".to_string()));
-        };
-        let Some(key) = func_ref.chunk.constants.get(b).copied() else {
-            return Err(vm.error(format!("Invalid constant index: {}", b)));
-        };
-
-        let table = vm.register_stack[*base_ptr + a];
-
+        let table = *vm.register_stack.get_unchecked(*base_ptr + a);
+        let key = *(*frame_ptr).constants_ptr.add(b);
         let value = if k {
-            let Some(constant) = func_ref.chunk.constants.get(c).copied() else {
-                return Err(vm.error(format!("Invalid constant index: {}", c)));
-            };
-            constant
+            *(*frame_ptr).constants_ptr.add(c)
         } else {
-            vm.register_stack[*base_ptr + c]
+            *vm.register_stack.get_unchecked(*base_ptr + c)
         };
-
         (table, key, value)
     };
 
     // FAST PATH: Direct table access without metamethod check for common case
     if let Some(table_id) = table_value.as_table_id() {
-        if let Some(table_ref) = vm.object_pool.get_table_mut(table_id) {
-            // Quick check: no metatable means no __newindex to worry about
-            if table_ref.get_metatable().is_none() {
-                // Ultra-fast path: direct set without any metamethod checks
-                table_ref.raw_set(key_value.clone(), set_value.clone());
+        // OPTIMIZED: Use unchecked access
+        let table_ref = unsafe { vm.object_pool.get_table_unchecked(table_id) };
 
-                // Note: GC barrier is handled lazily during collection
-                return Ok(());
-            }
+        // Quick check: no metatable means no __newindex to worry about
+        if table_ref.get_metatable().is_none() {
+            let table_ref = unsafe { vm.object_pool.get_table_mut_unchecked(table_id) };
+            // Ultra-fast path: direct set without any metamethod checks
+            table_ref.raw_set(key_value, set_value);
+            return Ok(());
         }
     }
 
