optimize table operation

CppCXY · CppCXY · commit af8f788e5dde · 2025-11-30T02:25:55.000+08:00
diff --git a/crates/luars/src/compiler/expr.rs b/crates/luars/src/compiler/expr.rs
@@ -2757,36 +2757,36 @@ fn compile_table_expr_to(
         }
     }
 
-    // Helper function to encode table size (Lua's int2fb encoding)
-    fn int2fb(x: usize) -> u32 {
-        if x < 8 {
-            x as u32
+    // Helper function to compute ceil(log2(x)) + 1 for hash size encoding
+    // This matches Lua's encoding: rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0
+    fn ceillog2_plus1(x: usize) -> u32 {
+        if x == 0 {
+            0
+        } else if x == 1 {
+            1
         } else {
-            let mut e = 0;
-            let mut x = x - 1;
-            while x >= 16 {
-                x = (x + 1) >> 1;
-                e += 1;
-            }
-            if x < 8 {
-                ((e + 1) << 3 | x) as u32
-            } else {
-                ((e + 2) << 3 | (x - 8)) as u32
-            }
+            // ceil(log2(x)) = number of bits needed to represent x-1, which is floor(log2(x-1)) + 1
+            // For x > 1: ceil(log2(x)) = 32 - (x-1).leading_zeros() for u32
+            let bits = usize::BITS - (x - 1).leading_zeros();
+            bits + 1 // +1 as per Lua encoding
         }
     }
 
     // Create table with size hints
-    // NEWTABLE A B C: B = hash size (encoded), C = array size (encoded)
-    let b_param = int2fb(hash_count);
-    let c_param = int2fb(array_count);
+    // NEWTABLE A B C k: B = log2(hash_size)+1, C = array_size % 256
+    // EXTRAARG contains array_size / 256 when k=1
+    const MAXARG_C: usize = 255;
+    let b_param = ceillog2_plus1(hash_count);
+    let extra = array_count / (MAXARG_C + 1); // higher bits of array size
+    let c_param = (array_count % (MAXARG_C + 1)) as u32; // lower bits of array size
+    let k = if extra > 0 { 1 } else { 0 };
     emit(
         c,
-        Instruction::encode_abc(OpCode::NewTable, reg, b_param, c_param),
+        Instruction::encode_abck(OpCode::NewTable, reg, b_param, c_param, k),
     );
 
-    // EXTRAARG instruction (always 0 for now, used for extended parameters)
-    emit(c, Instruction::create_ax(OpCode::ExtraArg, 0));
+    // EXTRAARG instruction for extended array size
+    emit(c, Instruction::create_ax(OpCode::ExtraArg, extra as u32));
 
     if fields.is_empty() {
         return Ok(reg);
@@ -2913,8 +2913,8 @@ fn compile_table_expr_to(
                     // key is a numeric literal - try SETI optimization
                     if !number_token.is_float() {
                         let int_value = number_token.get_int_value();
-                        // SETI: B field is sB (signed byte), range -128 to 127
-                        if int_value >= -128 && int_value <= 127 {
+                        // SETI: B field is unsigned byte, range 0-255
+                        if int_value >= 0 && int_value <= 255 {
                             // Try to compile value as constant first (for RK optimization)
                             let (value_operand, use_constant) =
                                 if let Some(value_expr) = field.get_value_expr() {
@@ -2929,9 +2929,8 @@ fn compile_table_expr_to(
                                     (r, false)
                                 };
 
-                            // Use SETI: R(A)[sB] := RK(C) where sB is signed byte
-                            // Encode sB: add OFFSET_SB (128)
-                            let encoded_b = (int_value + 128) as u32;
+                            // Use SETI: R(A)[B] := RK(C) where B is unsigned byte
+                            let encoded_b = int_value as u32;
                             emit(
                                 c,
                                 Instruction::create_abck(
@@ -2964,8 +2963,8 @@ fn compile_table_expr_to(
                 LuaIndexKey::Expr(key_expr) => {
                     // key is an expression - try to evaluate as constant integer for SETI
                     if let Some(int_val) = try_eval_const_int(&key_expr) {
-                        // SETI: B field is sB (signed byte), range -128 to 127
-                        if int_val >= -128 && int_val <= 127 {
+                        // SETI: B field is unsigned byte, range 0-255
+                        if int_val >= 0 && int_val <= 255 {
                             // Use SETI for small integer keys
                             let (value_operand, use_constant) =
                                 if let Some(value_expr) = field.get_value_expr() {
@@ -2980,8 +2979,8 @@ fn compile_table_expr_to(
                                     (r, false)
                                 };
 
-                            // Encode sB: add OFFSET_SB (128)
-                            let encoded_b = (int_val + 128) as u32;
+                            // B is unsigned byte
+                            let encoded_b = int_val as u32;
                             emit(
                                 c,
                                 Instruction::create_abck(
@@ -3128,13 +3127,12 @@ pub fn compile_var_expr(c: &mut Compiler, var: &LuaVarExpr, value_reg: u32) -> R
 
             match index_key {
                 LuaIndexKey::Integer(number_token) => {
-                    // Optimized: table[integer] = value -> SETI A sB C k
-                    // B field is sB (signed byte), range -128 to 127
+                    // Optimized: table[integer] = value -> SETI A B C k
+                    // B field is unsigned byte, range 0-255
                     let int_value = number_token.get_int_value();
-                    if int_value >= -128 && int_value <= 127 {
-                        // Use SETI: R(A)[sB] := RK(C)
-                        // Encode sB: add OFFSET_SB (128) to get 0-255 range
-                        let encoded_b = (int_value + 128) as u32;
+                    if int_value >= 0 && int_value <= 255 {
+                        // Use SETI: R(A)[B] := RK(C)
+                        let encoded_b = int_value as u32;
                         emit(
                             c,
                             Instruction::encode_abc(OpCode::SetI, table_reg, encoded_b, value_reg),
diff --git a/crates/luars/src/lua_value/lua_table.rs b/crates/luars/src/lua_value/lua_table.rs
@@ -240,6 +240,8 @@ impl LuaTable {
 
     /// Fast integer key access - O(1) for array part
     /// Ultra-optimized hot path for ipairs iterations
+    /// Note: This only checks the array part for performance.
+    /// Use get_int_full() if the value might be in the hash part.
     #[inline(always)]
     pub fn get_int(&self, key: i64) -> Option<LuaValue> {
         if key > 0 {
@@ -257,6 +259,18 @@ impl LuaTable {
         None
     }
 
+    /// Integer key access that also checks hash part
+    /// Used by GETI when array lookup fails
+    #[inline]
+    pub fn get_int_full(&self, key: i64) -> Option<LuaValue> {
+        // First try array part (fast path)
+        if let Some(val) = self.get_int(key) {
+            return Some(val);
+        }
+        // Fall back to hash part
+        self.get_from_hash(&LuaValue::integer(key))
+    }
+
     /// Optimized string key access using &str - avoids LuaValue allocation
     /// This is a hot path for table access with string literals
     #[inline(always)]
diff --git a/crates/luars/src/lua_vm/execute/control_instructions.rs b/crates/luars/src/lua_vm/execute/control_instructions.rs
@@ -319,17 +319,22 @@ pub fn exec_lt(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -> LuaR
     };
 
     // OPTIMIZATION: Direct type tag comparison (inline integer/float checks)
-    use crate::lua_value::{TAG_FLOAT, TAG_INTEGER, TAG_STRING, TYPE_MASK};
+    use crate::lua_value::TYPE_MASK;
     let left_tag = left.primary & TYPE_MASK;
     let right_tag = right.primary & TYPE_MASK;
 
     // Combined type check for fast paths (single branch!)
-    let combined_tags = (left_tag << 16) | right_tag;
-    const INT_INT: u64 = (TAG_INTEGER << 16) | TAG_INTEGER;
-    const FLOAT_FLOAT: u64 = (TAG_FLOAT << 16) | TAG_FLOAT;
-    const INT_FLOAT: u64 = (TAG_INTEGER << 16) | TAG_FLOAT;
-    const FLOAT_INT: u64 = (TAG_FLOAT << 16) | TAG_INTEGER;
-    const STRING_STRING: u64 = (TAG_STRING << 16) | TAG_STRING;
+    // Note: Shift TAG values right by 48 bits to get small values (0-15) for combining
+    let left_tag_small = left_tag >> 48;
+    let right_tag_small = right_tag >> 48;
+    let combined_tags = (left_tag_small << 4) | right_tag_small;
+    
+    // Small tag values after >> 48: TAG_INTEGER=3, TAG_FLOAT=4, TAG_STRING=5
+    const INT_INT: u64 = (3 << 4) | 3;       // 0x33
+    const FLOAT_FLOAT: u64 = (4 << 4) | 4;   // 0x44
+    const INT_FLOAT: u64 = (3 << 4) | 4;     // 0x34
+    const FLOAT_INT: u64 = (4 << 4) | 3;     // 0x43
+    const STRING_STRING: u64 = (5 << 4) | 5; // 0x55
 
     let is_less = if combined_tags == INT_INT {
         // Fast integer path - single branch!
@@ -425,17 +430,22 @@ pub fn exec_le(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -> LuaR
     };
 
     // OPTIMIZATION: Direct type tag comparison with combined_tags (like LT)
-    use crate::lua_value::{TAG_FLOAT, TAG_INTEGER, TAG_STRING, TYPE_MASK};
+    use crate::lua_value::TYPE_MASK;
     let left_tag = left.primary & TYPE_MASK;
     let right_tag = right.primary & TYPE_MASK;
 
     // Combined type check for fast paths (single branch!)
-    let combined_tags = (left_tag << 16) | right_tag;
-    const INT_INT: u64 = (TAG_INTEGER << 16) | TAG_INTEGER;
-    const FLOAT_FLOAT: u64 = (TAG_FLOAT << 16) | TAG_FLOAT;
-    const INT_FLOAT: u64 = (TAG_INTEGER << 16) | TAG_FLOAT;
-    const FLOAT_INT: u64 = (TAG_FLOAT << 16) | TAG_INTEGER;
-    const STRING_STRING: u64 = (TAG_STRING << 16) | TAG_STRING;
+    // Note: Shift TAG values right by 48 bits to get small values (0-15) for combining
+    let left_tag_small = left_tag >> 48;
+    let right_tag_small = right_tag >> 48;
+    let combined_tags = (left_tag_small << 4) | right_tag_small;
+    
+    // Small tag values after >> 48: TAG_INTEGER=3, TAG_FLOAT=4, TAG_STRING=5
+    const INT_INT: u64 = (3 << 4) | 3;       // 0x33
+    const FLOAT_FLOAT: u64 = (4 << 4) | 4;   // 0x44
+    const INT_FLOAT: u64 = (3 << 4) | 4;     // 0x34
+    const FLOAT_INT: u64 = (4 << 4) | 3;     // 0x43
+    const STRING_STRING: u64 = (5 << 4) | 5; // 0x55
 
     let is_less_or_equal = if combined_tags == INT_INT {
         // Fast integer path - single branch!
diff --git a/crates/luars/src/lua_vm/execute/table_instructions.rs b/crates/luars/src/lua_vm/execute/table_instructions.rs
@@ -6,43 +6,54 @@ use crate::lua_vm::{Instruction, LuaCallFrame, LuaResult, LuaVM};
 
 /// NEWTABLE A B C k
 /// R[A] := {} (size = B,C)
+/// B = log2(hash_size) + 1 (0 means no hash part)
+/// C = array_size % 256
+/// k = 1 means EXTRAARG follows with array_size / 256
 /// OPTIMIZED: Fast path for common empty/small table case
 #[inline(always)]
 pub fn exec_newtable(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) {
     let a = Instruction::get_a(instr) as usize;
-    let b = Instruction::get_b(instr);
-    let c = Instruction::get_c(instr);
+    let b = Instruction::get_b(instr); // log2(hash_size) + 1
+    let c = Instruction::get_c(instr); // array_size % 256
+    let k = Instruction::get_k(instr); // true if EXTRAARG has high bits of array_size
+
+    // Decode hash size: if b > 0, hash_size = 2^(b-1)
+    let hash_size = if b > 0 {
+        1usize << (b - 1)
+    } else {
+        0
+    };
 
     let (base_ptr, func_value) = unsafe {
         (*frame_ptr).pc += 1; // Skip EXTRAARG
         ((*frame_ptr).base_ptr, (*frame_ptr).function_value)
     };
 
-    // Calculate array size hint
-    let array_size = if b > 0 {
-        // FAST PATH: Small table, no EXTRAARG needed
-        (b - 1) as usize
-    } else {
+    // Calculate array size - C is low bits, EXTRAARG has high bits when k=1
+    let array_size = if k {
         // Need to read EXTRAARG for large arrays
         let pc = unsafe { (*frame_ptr).pc - 1 }; // We already incremented pc
         // Use new ID-based API to get function and read EXTRAARG
         if let Some(func_id) = func_value.as_function_id() {
             if let Some(func_ref) = vm.object_pool.get_function(func_id) {
                 if pc < func_ref.chunk.code.len() {
-                    Instruction::get_ax(func_ref.chunk.code[pc]) as usize
+                    let extra = Instruction::get_ax(func_ref.chunk.code[pc]) as usize;
+                    extra * 256 + c as usize // MAXARG_C + 1 = 256
                 } else {
-                    0
+                    c as usize
                 }
             } else {
-                0
+                c as usize
             }
         } else {
-            0
+            c as usize
         }
+    } else {
+        c as usize
     };
 
-    // Create new table with size hints
-    let table = vm.create_table(array_size, c as usize);
+    // Create new table with size hints (array_size, hash_size)
+    let table = vm.create_table(array_size, hash_size);
 
     // Store in register - use unchecked for speed
     unsafe {
@@ -170,13 +181,13 @@ pub fn exec_settable(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -
 }
 
 /// GETI A B C
-/// R[A] := R[B][sC:integer]
-/// OPTIMIZED: Direct integer access using get_int() without creating LuaValue key
+/// R[A] := R[B][C:integer]
+/// OPTIMIZED: Direct integer access using get_int_full() without creating LuaValue key
 #[inline(always)]
 pub fn exec_geti(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -> LuaResult<()> {
     let a = Instruction::get_a(instr) as usize;
     let b = Instruction::get_b(instr) as usize;
-    let c = Instruction::get_sc(instr) as i64; // sC is the signed integer index
+    let c = Instruction::get_c(instr) as i64; // C is unsigned integer index
 
     let base_ptr = unsafe { (*frame_ptr).base_ptr };
     let table = unsafe { *vm.register_stack.get_unchecked(base_ptr + b) };
@@ -186,8 +197,9 @@ pub fn exec_geti(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -> Lu
         // SAFETY: table_id is valid because it came from as_table_id()
         let lua_table = unsafe { vm.object_pool.get_table_unchecked(table_id) };
         
-        // OPTIMIZATION: Use get_int directly - C is already the integer index!
-        if let Some(val) = lua_table.get_int(c) {
+        // Use get_int_full to check both array and hash parts
+        // This is necessary because integer keys may be stored in hash if array wasn't pre-allocated
+        if let Some(val) = lua_table.get_int_full(c) {
             unsafe { *vm.register_stack.get_unchecked_mut(base_ptr + a) = val };
             return Ok(());
         }
@@ -215,7 +227,7 @@ pub fn exec_geti(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -> Lu
 #[inline(always)]
 pub fn exec_seti(vm: &mut LuaVM, instr: u32, frame_ptr: *mut LuaCallFrame) -> LuaResult<()> {
     let a = Instruction::get_a(instr) as usize;
-    let b = Instruction::get_sb(instr) as i64; // B is already the integer key
+    let b = Instruction::get_b(instr) as i64; // B is unsigned integer key
     let c = Instruction::get_c(instr) as usize;
     let k = Instruction::get_k(instr);
 
diff --git a/crates/luars/src/lua_vm/opcode/mod.rs b/crates/luars/src/lua_vm/opcode/mod.rs
@@ -397,6 +397,11 @@ impl Instruction {
         Self::create_abc(op, a, b, c)
     }
 
+    #[inline(always)]
+    pub fn encode_abck(op: OpCode, a: u32, b: u32, c: u32, k: u32) -> u32 {
+        Self::create_abck(op, a, b, c, k != 0)
+    }
+
     #[inline(always)]
     pub fn encode_abx(op: OpCode, a: u32, bx: u32) -> u32 {
         Self::create_abx(op, a, bx)
diff --git a/crates/luars_interpreter/src/bin/bytecode_dump.rs b/crates/luars_interpreter/src/bin/bytecode_dump.rs
@@ -165,15 +165,13 @@ fn dump_chunk(chunk: &Chunk, name: &str, depth: usize) {
             }
             OpCode::Len => format!("LEN {} {}", a, b),
             OpCode::GetI => {
-                // GETI A B sC: R[A] := R[B][sC]
-                let sc = Instruction::get_sc(instr);
-                format!("GetI {} {} {}", a, b, sc)
+                // GETI A B C: R[A] := R[B][C] - C is unsigned integer index
+                format!("GetI {} {} {}", a, b, c)
             }
             OpCode::SetI => {
-                // SETI A sB C/k: R[A][sB] := RK(C)
-                let sb = Instruction::get_sb(instr);
+                // SETI A B C/k: R[A][B] := RK(C) - B is unsigned integer index
                 let k_str = if k { "k" } else { "" };
-                format!("SetI {} {} {}{}", a, sb, c, k_str)
+                format!("SetI {} {} {}{}", a, b, c, k_str)
             }
             OpCode::EqK => {
                 // EQK A B k: if ((R[A] == K[B]) ~= k) then pc++
