From 9a83bd1cd3d2f56c7adddef3a7bb172d89135c52 Mon Sep 17 00:00:00 2001 From: esrrhs Date: Sat, 10 Oct 2026 22:46:45 +0800 Subject: [PATCH 1/2] Add Lua-style table array part Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- benchmark/README.md | 4 +- benchmark/README.zh.md | 4 +- src/compile/c_gen.cpp | 2 +- src/compile/c_runtime_header.h | 234 ++++++++++++++++++----- src/interp/runtime.cpp | 10 +- src/native/table/native_table.cpp | 138 ++++++++++++- src/state/fakelua.cpp | 13 +- src/var/var_table.h | 5 + test/lua/table/test_table_array_part.lua | 87 +++++++++ test/test_table.cpp | 15 ++ 10 files changed, 462 insertions(+), 50 deletions(-) create mode 100644 test/lua/table/test_table_array_part.lua diff --git a/benchmark/README.md b/benchmark/README.md index 77d20b7..9b3008e 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -4,6 +4,8 @@ This file records results of running `bench_mark` compiled in **Release mode** (`-O3 -DNDEBUG`) locally. It covers **51 Lua performance scenarios across 6 categories**, each with C++ / Lua 5.4 / FakeLua TCC / FakeLua GCC / FakeLua INTERP (bytecode interpreter). Analysis below splits into **interpreter vs Lua 5.4** (this machine, 2026-09-16) and **GCC JIT vs Lua / C++** (previous machine, 2026-08-14). +These benchmark results predate the table array-part implementation; table-performance figures and notes below are historical baselines, not measurements of the current code. + ## Running ```bash @@ -125,7 +127,7 @@ Largest parameter per scenario: 3. **Tail recursion is the outlier (34×)**: Lua 5.4 turns `return f(...)` into a loop. INTERP does not; n=5000 is 5000 nested C frames (and overflows the default 8 MiB stack). -4. **Table loops without an array part are ~3–4× slower** (BubbleSort, Vector3, TableInsert, NestedTable). Hash-only `VarTable` vs Lua's array part. +4. **In these pre-array-part measurements, table loops were ~3–4× slower** (BubbleSort, Vector3, TableInsert, NestedTable). At the time, `VarTable` used hash-only storage while Lua used an array part. 5. **C stdlib work can beat Lua**: `string.lower`/`upper` **6.2×**, `string.len` 2.3×, `table.sort` 1.9×, TableChurn 2.2× (arena). When the opcode loop is not the bottleneck, native helpers plus no-GC allocation win. diff --git a/benchmark/README.zh.md b/benchmark/README.zh.md index aa3b7bc..2ab0523 100644 --- a/benchmark/README.zh.md +++ b/benchmark/README.zh.md @@ -2,6 +2,8 @@ 本文件记录在本地以 **Release 模式**（`-O3 -DNDEBUG`）编译运行 `bench_mark` 的结果。覆盖 **6 大类共 51 个 Lua 性能场景**，每个场景均实现 C++ / Lua 5.4 / FakeLua TCC / FakeLua GCC / FakeLua INTERP（字节码解释器）横向对比。下面分析分成两块：**解释器 vs Lua 5.4**（本机，2026-09-16）和 **GCC JIT vs Lua / C++**（上一台机器，2026-08-14）。 +以下基准结果早于表数组部分的实现；表性能数据和说明是历史基线，不代表当前代码的测量结果。 + ## 运行命令 ```bash @@ -123,7 +125,7 @@ build/bin/bench_mark --benchmark_repetitions=1 --benchmark_report_aggregates_onl 3. **尾递归是离群点（34 倍）**：Lua 5.4 把 `return f(...)` 收成循环。INTERP 没有；n=5000 是 5000 层 C 栈（默认 8 MiB 会溢出）。 -4. **没有 array part 的表循环大约慢 3–4 倍**（BubbleSort、Vector3、TableInsert、NestedTable）。哈希-only 的 `VarTable` 对上 Lua 的数组部分。 +4. **在这些实现数组部分之前的测量中，表循环大约慢 3–4 倍**（BubbleSort、Vector3、TableInsert、NestedTable）。当时 `VarTable` 只有哈希存储，而 Lua 使用数组部分。 5. **落到 C 标准库的工作可以快过 Lua**：`string.lower`/`upper` **6.2 倍**、`string.len` 2.3 倍、`table.sort` 1.9 倍、TableChurn 2.2 倍（arena）。操作码循环不是瓶颈时，原生辅助函数加上无 GC 分配会赢。 diff --git a/src/compile/c_gen.cpp b/src/compile/c_gen.cpp index 3166058..9577ff2 100644 --- a/src/compile/c_gen.cpp +++ b/src/compile/c_gen.cpp @@ -2157,7 +2157,7 @@ void CGen::CompileStmtForIn(const SyntaxTreeInterfacePtr &stmt) { Out() << GenTab() << tbl_var << " = " << tbl_expr << ";\n"; Out() << GenTab() << "if (UNLIKELY(" << tbl_var << ".type_ != VAR_TABLE)) { FakeluaThrowError(_S, \"for in: not a table\"); }\n"; - Out() << GenTab() << sz_var << " = " << tbl_var << ".data_.t->count_ + " << tbl_var << ".data_.t->spec_count;\n"; + Out() << GenTab() << sz_var << " = " << tbl_var << ".data_.t->count_ + " << tbl_var << ".data_.t->spec_count + " << tbl_var << ".data_.t->arr_size_;\n"; Out() << GenTab() << "for (" << idx_var << " = 0; " << idx_var << " < " << sz_var << "; " << idx_var << "++) {\n"; cur_tab_++; diff --git a/src/compile/c_runtime_header.h b/src/compile/c_runtime_header.h index 1080e38..b27be25 100644 --- a/src/compile/c_runtime_header.h +++ b/src/compile/c_runtime_header.h @@ -82,6 +82,12 @@ struct VarTable { 需要重算——因此把 VarTable 整体清零的分配路径天然落在安全的重算分支上。 */ uint32_t seq_len_valid_; int64_t seq_len_; + /* 数组部分：整数键 1..arr_size_ 只存放在 arr_ 中（允许 nil 空洞），哈希部分不含 [1, arr_size_+1] + 范围内的整数键。arr_size_ 只增不减，遍历时偏移保持稳定。spec 表不使用数组部分。 + 哈希部分写满时按 Lua 的规则（整数键占用率 > 50%）把整数键迁入数组，见 FlArrTryResize。 */ + CVar *arr_; + uint32_t arr_size_; + uint32_t arr_cap_; }; typedef struct State State; @@ -117,6 +123,7 @@ static inline bool FlTableHasIntKey(VarTable *t, int64_t k) { CVar __r = t->spec_get(t, key_cvar, &__finish); if (__finish) return __r.type_ != VAR_NIL; } + if ((uint64_t)k - 1 < (uint64_t)t->arr_size_) { return t->arr_[k - 1].type_ != VAR_NIL; } if (t->spec_count > 0 && t->spec_keys && t->spec_vals) { uint32_t i; for (i = 0; i < t->spec_count; ++i) { @@ -187,7 +194,7 @@ static inline void FlSeqNoteIntSet(VarTable *t, int64_t k, bool is_nil) { if (t->seq_len_ < INT64_MAX && k == t->seq_len_ + 1) { t->seq_len_ = FlSeqScanFrom(t, k); } } -#define TABLE_SIZE(t) ((t)->count_ + (t)->spec_count) +#define TABLE_SIZE(t) ((t)->count_ + (t)->spec_count + (t)->arr_size_) typedef struct VarMulti { uint32_t count; @@ -659,6 +666,9 @@ static inline uint32_t FlHashString(const char *str, int len) { __t->spec_count = 0; \ __t->seq_len_valid_ = 1; \ __t->seq_len_ = 0; \ + __t->arr_ = NULL; \ + __t->arr_size_ = 0; \ + __t->arr_cap_ = 0; \ assert(sizeof(__t->quick_data_) == 8 * sizeof(VarEntry)); \ { int __i; for (__i = 0; __i < 8; ++__i) { \ __t->quick_data_[__i].key.type_ = VAR_NIL; \ @@ -761,6 +771,7 @@ static inline CVar FlGetTable(CVar t, CVar k) { CVar __r = tbl->spec_get(tbl, k, &__finish); if (__finish) return __r; } + if (k.type_ == VAR_INT && (uint64_t)k.data_.i - 1 < (uint64_t)tbl->arr_size_) { return tbl->arr_[k.data_.i - 1]; } if (UNLIKELY(tbl->count_ == 0)) { return (CVar){VAR_NIL}; } uint32_t h; VarHash(k, h); if (LIKELY(tbl->bucket_count_ == 0)) { @@ -863,17 +874,9 @@ static inline void FlTableRehash(VarTable *tbl) { } } -static inline void FlSetTableImpl(CVar t, CVar k, CVar v) { - k = NORMALIZE_TABLE_KEY(k); - if (UNLIKELY(t.type_ != VAR_TABLE)) { FakeluaThrowError(_S, "attempt to index a non-table value"); } - if (UNLIKELY(k.type_ == VAR_NIL)) { FakeluaThrowError(_S, "table index is nil"); } - if (UNLIKELY(k.type_ == VAR_FLOAT && isnan(k.data_.f))) { FakeluaThrowError(_S, "table index is NaN"); } - VarTable *tbl = t.data_.t; - if (tbl->spec_set) { - bool __finish = false; - tbl->spec_set(tbl, k, v, &__finish); - if (__finish) return; - } +static inline bool FlArrResizeInsert(VarTable *tbl, CVar k, CVar v); + +static inline void FlHashSet(VarTable *tbl, CVar k, CVar v) { uint32_t h; VarHash(k, h); if (UNLIKELY(v.type_ == VAR_NIL)) { if (UNLIKELY(tbl->count_ == 0)) { return; } @@ -927,29 +930,17 @@ static inline void FlSetTableImpl(CVar t, CVar k, CVar v) { if (tbl->count_ > 6 && tbl->quick_data_[6].hash == h) { VarEqual(tbl->quick_data_[6].key, k, __eq); if (__eq) { tbl->quick_data_[6].val = v; return; } } if (tbl->count_ > 7 && tbl->quick_data_[7].hash == h) { VarEqual(tbl->quick_data_[7].key, k, __eq); if (__eq) { tbl->quick_data_[7].val = v; return; } } if (tbl->count_ < 8) { tbl->quick_data_[tbl->count_].key = k; tbl->quick_data_[tbl->count_].val = v; tbl->quick_data_[tbl->count_].hash = h; tbl->count_++; return; } + if (k.type_ == VAR_INT && FlArrResizeInsert(tbl, k, v)) { return; } FlTableRehash(tbl); } - if (UNLIKELY(tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == 0xFFFFFFFF)) { FlTableRehash(tbl); } - FlTableInsertRaw(tbl, k, v, h); -} - -static inline void FlSetTable(CVar t, CVar k, CVar v) { - FlSetTableImpl(t, k, v); - if (LIKELY(t.type_ == VAR_TABLE)) { - CVar __nk = NORMALIZE_TABLE_KEY(k); - if (__nk.type_ == VAR_INT) { FlSeqNoteIntSet(t.data_.t, __nk.data_.i, v.type_ == VAR_NIL); } + if (UNLIKELY(tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == 0xFFFFFFFF)) { + if (k.type_ == VAR_INT && FlArrResizeInsert(tbl, k, v)) { return; } + FlTableRehash(tbl); } + FlTableInsertRaw(tbl, k, v, h); } -static inline CVar FlGetTableInt(CVar t, int64_t k) { - if (UNLIKELY(t.type_ != VAR_TABLE)) { FakeluaThrowError(_S, "attempt to index a non-table value"); } - VarTable *tbl = t.data_.t; - if (tbl->spec_get) { - CVar key_cvar; key_cvar.type_ = VAR_INT; key_cvar.data_.i = k; - bool __finish = false; - CVar __r = tbl->spec_get(tbl, key_cvar, &__finish); - if (__finish) return __r; - } +static inline CVar FlHashGetInt(VarTable *tbl, int64_t k) { if (UNLIKELY(tbl->count_ == 0)) { return (CVar){VAR_NIL}; } uint32_t h = (uint32_t)(k ^ (k >> 32)); if (LIKELY(tbl->bucket_count_ == 0)) { @@ -975,6 +966,136 @@ static inline CVar FlGetTableInt(CVar t, int64_t k) { return (CVar){VAR_NIL}; } +__attribute__((noinline)) static void FlArrGrow(VarTable *tbl) { + uint32_t cap = tbl->arr_cap_ ? tbl->arr_cap_ * 2 : 4; + CVar *na = (CVar *)FakeluaAlloc(_S, (size_t)cap * sizeof(CVar), !__fakelua_init_flag__); + if (tbl->arr_size_ > 0) { memcpy(na, tbl->arr_, (size_t)tbl->arr_size_ * sizeof(CVar)); } + tbl->arr_ = na; + tbl->arr_cap_ = cap; +} + +/* 数组末尾追加后，把哈希部分中紧随其后的整数键迁入数组，维持「哈希不含 [1, arr_size_+1]」。*/ +__attribute__((noinline)) static void FlArrMigrate(VarTable *tbl) { + while (tbl->count_ != 0) { + int64_t nk = (int64_t)tbl->arr_size_ + 1; + CVar hv = FlHashGetInt(tbl, nk); + if (hv.type_ == VAR_NIL) { break; } + CVar key; key.type_ = VAR_INT; key.flag_ = 0; key.data_.i = nk; + FlHashSet(tbl, key, (CVar){VAR_NIL}); + if (UNLIKELY(tbl->arr_size_ == tbl->arr_cap_)) { FlArrGrow(tbl); } + tbl->arr_[tbl->arr_size_++] = hv; + } +} + +/* 整数键写入的数组部分快路径。返回 true 表示已处理。*/ +static inline bool FlArrSetInt(VarTable *tbl, int64_t k, CVar v) { + uint64_t idx = (uint64_t)k - 1; + if (LIKELY(idx < (uint64_t)tbl->arr_size_)) { tbl->arr_[idx] = v; return true; } + if (idx == (uint64_t)tbl->arr_size_ && v.type_ != VAR_NIL && !tbl->spec_set) { + if (UNLIKELY(tbl->arr_size_ == tbl->arr_cap_)) { FlArrGrow(tbl); } + tbl->arr_[tbl->arr_size_++] = v; + if (UNLIKELY(tbl->count_ != 0)) { FlArrMigrate(tbl); } + return true; + } + return false; +} + +/* 哈希部分写满、即将为整数键 nk 扩容前，按 Lua 的 computesizes 规则判断是否应把整数键迁入数组： + 选取最大的 2^i，使 1..2^i 内的整数键数量超过 2^i 的一半。返回 true 表示数组已扩大。 */ +__attribute__((noinline)) static bool FlArrTryResize(VarTable *tbl, int64_t nk) { + uint32_t nums[32]; + uint64_t total = 0; + uint32_t i; + memset(nums, 0, sizeof(nums)); +#define FL_COUNT_INT_KEY(kk) do { \ + int64_t __ck = (kk); \ + if (__ck >= 1 && __ck <= (1LL << 30)) { nums[__ck == 1 ? 0 : 64 - __builtin_clzll((uint64_t)__ck - 1)]++; total++; } \ +} while(0) + for (i = 0; i < tbl->arr_size_; ++i) { if (tbl->arr_[i].type_ != VAR_NIL) { FL_COUNT_INT_KEY((int64_t)i + 1); } } + if (tbl->bucket_count_ == 0) { + for (i = 0; i < tbl->count_; ++i) { + if (tbl->quick_data_[i].key.type_ == VAR_INT) { FL_COUNT_INT_KEY(tbl->quick_data_[i].key.data_.i); } + } + } else { + for (i = 0; i < tbl->count_; ++i) { + VarEntry *e = &tbl->nodes_[tbl->active_list_[i]].entry; + if (e->key.type_ == VAR_INT) { FL_COUNT_INT_KEY(e->key.data_.i); } + } + } + FL_COUNT_INT_KEY(nk); +#undef FL_COUNT_INT_KEY + uint64_t a = 0, optimal = 0, two = 1; + for (i = 0; i < 31 && total > two / 2; ++i, two <<= 1) { + a += nums[i]; + if (a > two / 2) { optimal = two; } + } + if (optimal <= (uint64_t)tbl->arr_size_) { return false; } + { + uint32_t old_size = tbl->arr_size_; + CVar *na = (CVar *)FakeluaAlloc(_S, (size_t)optimal * sizeof(CVar), !__fakelua_init_flag__); + if (old_size > 0) { memcpy(na, tbl->arr_, (size_t)old_size * sizeof(CVar)); } + memset(na + old_size, 0, (size_t)(optimal - old_size) * sizeof(CVar)); + tbl->arr_ = na; + tbl->arr_cap_ = (uint32_t)optimal; + tbl->arr_size_ = (uint32_t)optimal; + if (tbl->count_ != 0) { + uint64_t j; + for (j = old_size + 1; j <= optimal && tbl->count_ != 0; ++j) { + CVar hv = FlHashGetInt(tbl, (int64_t)j); + if (hv.type_ == VAR_NIL) { continue; } + CVar key; key.type_ = VAR_INT; key.flag_ = 0; key.data_.i = (int64_t)j; + FlHashSet(tbl, key, (CVar){VAR_NIL}); + tbl->arr_[j - 1] = hv; + } + FlArrMigrate(tbl); + } + } + return true; +} + +/* 整数键 k 要插入已写满的哈希部分前调用；返回 true 表示 k 已写入数组，调用方直接返回。*/ +static inline bool FlArrResizeInsert(VarTable *tbl, CVar k, CVar v) { + if (k.type_ != VAR_INT || tbl->spec_set) { return false; } + if (!FlArrTryResize(tbl, k.data_.i)) { return false; } + return FlArrSetInt(tbl, k.data_.i, v); +} + +static inline void FlSetTableImpl(CVar t, CVar k, CVar v) { + k = NORMALIZE_TABLE_KEY(k); + if (UNLIKELY(t.type_ != VAR_TABLE)) { FakeluaThrowError(_S, "attempt to index a non-table value"); } + if (UNLIKELY(k.type_ == VAR_NIL)) { FakeluaThrowError(_S, "table index is nil"); } + if (UNLIKELY(k.type_ == VAR_FLOAT && isnan(k.data_.f))) { FakeluaThrowError(_S, "table index is NaN"); } + VarTable *tbl = t.data_.t; + if (tbl->spec_set) { + bool __finish = false; + tbl->spec_set(tbl, k, v, &__finish); + if (__finish) return; + } + if (k.type_ == VAR_INT && FlArrSetInt(tbl, k.data_.i, v)) { return; } + FlHashSet(tbl, k, v); +} + +static inline void FlSetTable(CVar t, CVar k, CVar v) { + FlSetTableImpl(t, k, v); + if (LIKELY(t.type_ == VAR_TABLE)) { + CVar __nk = NORMALIZE_TABLE_KEY(k); + if (__nk.type_ == VAR_INT) { FlSeqNoteIntSet(t.data_.t, __nk.data_.i, v.type_ == VAR_NIL); } + } +} + +static inline CVar FlGetTableInt(CVar t, int64_t k) { + if (UNLIKELY(t.type_ != VAR_TABLE)) { FakeluaThrowError(_S, "attempt to index a non-table value"); } + VarTable *tbl = t.data_.t; + if (LIKELY((uint64_t)k - 1 < (uint64_t)tbl->arr_size_)) { return tbl->arr_[k - 1]; } + if (tbl->spec_get) { + CVar key_cvar; key_cvar.type_ = VAR_INT; key_cvar.data_.i = k; + bool __finish = false; + CVar __r = tbl->spec_get(tbl, key_cvar, &__finish); + if (__finish) return __r; + } + return FlHashGetInt(tbl, k); +} + static inline void FlSetTableIntImpl(CVar t, int64_t k, CVar v) { if (UNLIKELY(t.type_ != VAR_TABLE)) { FakeluaThrowError(_S, "attempt to index a non-table value"); } if (UNLIKELY(t.flag_ & CONST_FLAG)) { FakeluaThrowError(_S, "attempt to modify a const table"); } @@ -985,10 +1106,11 @@ static inline void FlSetTableIntImpl(CVar t, int64_t k, CVar v) { tbl->spec_set(tbl, key_cvar, v, &__finish); if (__finish) return; } + if (FlArrSetInt(tbl, k, v)) { return; } uint32_t h = (uint32_t)(k ^ (k >> 32)); CVar key_cvar; key_cvar.type_ = VAR_INT; key_cvar.data_.i = k; if (UNLIKELY(v.type_ == VAR_NIL)) { - FlSetTable(t, key_cvar, v); + FlHashSet(tbl, key_cvar, v); return; } if (LIKELY(tbl->bucket_count_ == 0)) { @@ -1003,13 +1125,26 @@ static inline void FlSetTableIntImpl(CVar t, int64_t k, CVar v) { tbl->quick_data_[tbl->count_].hash = h; tbl->count_++; return; } + if (FlArrResizeInsert(tbl, key_cvar, v)) { return; } + FlTableRehash(tbl); + } + if (UNLIKELY(tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == 0xFFFFFFFF)) { + if (FlArrResizeInsert(tbl, key_cvar, v)) { return; } FlTableRehash(tbl); } - if (UNLIKELY(tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == 0xFFFFFFFF)) { FlTableRehash(tbl); } FlTableInsertRaw(tbl, key_cvar, v, h); } static inline void FlSetTableInt(CVar t, int64_t k, CVar v) { + if (LIKELY(t.type_ == VAR_TABLE && !(t.flag_ & CONST_FLAG))) { + VarTable *tbl = t.data_.t; + uint64_t idx = (uint64_t)k - 1; + /* 新旧值都非 nil 时序列长度不变，可跳过缓存维护。*/ + if (LIKELY(idx < (uint64_t)tbl->arr_size_ && v.type_ != VAR_NIL && tbl->arr_[idx].type_ != VAR_NIL)) { + tbl->arr_[idx] = v; + return; + } + } FlSetTableIntImpl(t, k, v); if (LIKELY(t.type_ == VAR_TABLE)) { FlSeqNoteIntSet(t.data_.t, k, v.type_ == VAR_NIL); } } @@ -1558,7 +1693,7 @@ static inline CVar FlTableMove(CVar src, int64_t f, int64_t e, int64_t t, CVar d (CVar){.type_ = VAR_INT, .data_.i = t}, dst); } - if (!same && dst.data_.t->count_ == 0 && icount > 8) { + if (!same && dst.data_.t->count_ == 0 && icount > 8 && t != (int64_t)dst.data_.t->arr_size_ + 1) { FlEnsureTableBuckets(dst.data_.t, (uint32_t)icount); } { int64_t i; for (i = 0; i < icount; ++i) { @@ -1569,17 +1704,30 @@ static inline CVar FlTableMove(CVar src, int64_t f, int64_t e, int64_t t, CVar d } #define GET_TABLE_ENTRY(tbl, idx, k, v) do { \ - uint32_t __spec_cnt = (tbl).data_.t->spec_count; \ - if (LIKELY((idx) < __spec_cnt)) { \ - (k) = (tbl).data_.t->spec_keys[(idx)]; \ - (v) = (tbl).data_.t->spec_vals[(idx)]; \ - } else if (LIKELY((tbl).data_.t->bucket_count_ == 0)) { \ - (k) = (tbl).data_.t->quick_data_[(idx) - __spec_cnt].key; \ - (v) = (tbl).data_.t->quick_data_[(idx) - __spec_cnt].val; \ + VarTable *__gt = (tbl).data_.t; \ + uint32_t __gi = (idx); \ + uint32_t __spec_cnt = __gt->spec_count; \ + if (LIKELY(__gi < __spec_cnt)) { \ + (k) = __gt->spec_keys[__gi]; \ + (v) = __gt->spec_vals[__gi]; \ } else { \ - uint32_t __gti_node_idx = (tbl).data_.t->active_list_[(idx) - __spec_cnt]; \ - (k) = (tbl).data_.t->nodes_[__gti_node_idx].entry.key; \ - (v) = (tbl).data_.t->nodes_[__gti_node_idx].entry.val; \ + __gi -= __spec_cnt; \ + if (__gi < __gt->arr_size_) { \ + (k).type_ = VAR_INT; (k).flag_ = 0; (k).data_.i = (int64_t)__gi + 1; \ + (v) = __gt->arr_[__gi]; \ + } else { \ + __gi -= __gt->arr_size_; \ + if (UNLIKELY(__gi >= __gt->count_)) { \ + (k).type_ = VAR_NIL; (v).type_ = VAR_NIL; \ + } else if (LIKELY(__gt->bucket_count_ == 0)) { \ + (k) = __gt->quick_data_[__gi].key; \ + (v) = __gt->quick_data_[__gi].val; \ + } else { \ + uint32_t __gti_node_idx = __gt->active_list_[__gi]; \ + (k) = __gt->nodes_[__gti_node_idx].entry.key; \ + (v) = __gt->nodes_[__gti_node_idx].entry.val; \ + } \ + } \ } \ } while(0) diff --git a/src/interp/runtime.cpp b/src/interp/runtime.cpp index e149399..d930121 100644 --- a/src/interp/runtime.cpp +++ b/src/interp/runtime.cpp @@ -142,7 +142,13 @@ bool TableEntry(CVar t, uint32_t idx, CVar &k, CVar &v) { v = tbl->spec_vals[idx]; return true; } - const uint32_t hidx = idx - spec_cnt; + uint32_t hidx = idx - spec_cnt; + if (hidx < tbl->arr_size_) { + k = Int(static_cast(hidx) + 1); + v = tbl->arr_[hidx]; + return true; + } + hidx -= tbl->arr_size_; if (tbl->bucket_count_ == 0) { if (hidx >= tbl->count_) return false; k = tbl->quick_data_[hidx].key; @@ -160,7 +166,7 @@ uint32_t TableEntryCount(CVar t) { if (t.type_ != kTable || !t.data_.t) { ThrowFakeluaException("for in: not a table"); } - return t.data_.t->count_ + t.data_.t->spec_count; + return t.data_.t->count_ + t.data_.t->spec_count + t.data_.t->arr_size_; } CVar CombineMulti(State *s, const CVar *prefix, uint32_t prefix_count, CVar last) { diff --git a/src/native/table/native_table.cpp b/src/native/table/native_table.cpp index 02192e9..2a8e730 100644 --- a/src/native/table/native_table.cpp +++ b/src/native/table/native_table.cpp @@ -109,6 +109,7 @@ bool TableHasIntKey(const VarTable *t, int64_t k) { CVar r = get_fn(const_cast(t), key_cvar, &finish); if (finish) return r.type_ != kNilType; } + if (static_cast(k) - 1 < t->arr_size_) return t->arr_[k - 1].type_ != kNilType; if (t->spec_count > 0 && t->spec_keys && t->spec_vals) { for (uint32_t i = 0; i < t->spec_count; ++i) { if (TableHelper::VarKeyEqualInt(t->spec_keys[i], k) && t->spec_vals[i].type_ != kNilType) return true; @@ -306,6 +307,8 @@ void TableRehashTo(State *s, VarTable *tbl, uint32_t min_buckets) { } } +bool TableArrResizeInsert(State *s, VarTable *tbl, int64_t k, CVar v); + // 通用的键写入，与 FlSetTableImpl 的插入路径对应（不含 nil 删除）。 void TableSetNonNil(State *s, VarTable *tbl, CVar key, CVar val, uint32_t hash) { if (tbl->bucket_count_ == 0) { @@ -324,9 +327,11 @@ void TableSetNonNil(State *s, VarTable *tbl, CVar key, CVar val, uint32_t hash) tbl->count_++; return; } + if (key.type_ == kIntType && TableArrResizeInsert(s, tbl, key.data_.i, val)) return; TableRehash(s, tbl); } if (tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == VarTable::INVALID_INDEX) { + if (key.type_ == kIntType && TableArrResizeInsert(s, tbl, key.data_.i, val)) return; TableRehash(s, tbl); } TableInsertRaw(tbl, key, val, hash); @@ -398,6 +403,119 @@ void TableDelete(VarTable *tbl, CVar key, uint32_t hash) { } } +// 仅查哈希部分的整数键（不含 spec 与数组部分）。 +CVar TableHashGetInt(const VarTable *t, int64_t k) { + const CVar nil{kNilType}; + if (t->count_ == 0) return nil; + const uint32_t hash = IntKeyHash(k); + if (t->bucket_count_ == 0) { + for (uint32_t i = 0; i < t->count_; ++i) { + const auto &qd = t->quick_data_[i]; + if (qd.hash == hash && qd.key.type_ == kIntType && qd.key.data_.i == k) return qd.val; + } + return nil; + } + const auto *curr = &t->nodes_[hash & (t->bucket_count_ - 1)]; + while (true) { + if (curr->entry.hash == hash && curr->entry.key.type_ == kIntType && curr->entry.key.data_.i == k) return curr->entry.val; + if (curr->next == VarTable::INVALID_INDEX) return nil; + curr = &t->nodes_[curr->next]; + } +} + +void TableArrGrow(State *s, VarTable *tbl) { + const uint32_t cap = tbl->arr_cap_ ? tbl->arr_cap_ * 2 : 4; + auto *na = static_cast(s->GetValueAllocator().Alloc(static_cast(cap) * sizeof(CVar))); + if (tbl->arr_size_ > 0) std::memcpy(na, tbl->arr_, static_cast(tbl->arr_size_) * sizeof(CVar)); + tbl->arr_ = na; + tbl->arr_cap_ = cap; +} + +// 与 c_runtime_header.h 的 FlArrSetInt 对应：数组末尾追加后把哈希部分紧随其后的整数键迁入数组。 +bool TableArrSetInt(State *s, VarTable *tbl, int64_t k, CVar v) { + const uint64_t idx = static_cast(k) - 1; + if (idx < tbl->arr_size_) { + tbl->arr_[idx] = v; + return true; + } + if (idx != tbl->arr_size_ || v.type_ == kNilType || tbl->spec_set) return false; + if (tbl->arr_size_ == tbl->arr_cap_) TableArrGrow(s, tbl); + tbl->arr_[tbl->arr_size_++] = v; + while (tbl->count_ != 0) { + const int64_t nk = static_cast(tbl->arr_size_) + 1; + const CVar hv = TableHashGetInt(tbl, nk); + if (hv.type_ == kNilType) break; + CVar key{kIntType}; + key.data_.i = nk; + TableDelete(tbl, key, IntKeyHash(nk)); + if (tbl->arr_size_ == tbl->arr_cap_) TableArrGrow(s, tbl); + tbl->arr_[tbl->arr_size_++] = hv; + } + return true; +} + +// 与 c_runtime_header.h 的 FlArrTryResize 对应（Lua computesizes 规则）。 +bool TableArrTryResize(State *s, VarTable *tbl, int64_t nk) { + uint32_t nums[32] = {}; + uint64_t total = 0; + const auto count_key = [&](int64_t kk) { + if (kk >= 1 && kk <= (int64_t{1} << 30)) { + nums[kk == 1 ? 0 : 64 - __builtin_clzll(static_cast(kk) - 1)]++; + total++; + } + }; + for (uint32_t i = 0; i < tbl->arr_size_; ++i) { + if (tbl->arr_[i].type_ != kNilType) count_key(static_cast(i) + 1); + } + for (uint32_t i = 0; i < tbl->count_; ++i) { + const auto &e = tbl->bucket_count_ == 0 ? tbl->quick_data_[i] : tbl->nodes_[tbl->active_list_[i]].entry; + if (e.key.type_ == kIntType) count_key(e.key.data_.i); + } + count_key(nk); + uint64_t a = 0, optimal = 0, two = 1; + for (uint32_t i = 0; i < 31 && total > two / 2; ++i, two <<= 1) { + a += nums[i]; + if (a > two / 2) optimal = two; + } + if (optimal <= tbl->arr_size_) return false; + + const uint32_t old_size = tbl->arr_size_; + auto *na = static_cast(s->GetValueAllocator().Alloc(static_cast(optimal) * sizeof(CVar))); + if (old_size > 0) std::memcpy(na, tbl->arr_, static_cast(old_size) * sizeof(CVar)); + std::memset(static_cast(na + old_size), 0, static_cast(optimal - old_size) * sizeof(CVar)); + tbl->arr_ = na; + tbl->arr_cap_ = static_cast(optimal); + tbl->arr_size_ = static_cast(optimal); + for (uint64_t j = old_size + 1; j <= optimal && tbl->count_ != 0; ++j) { + const CVar hv = TableHashGetInt(tbl, static_cast(j)); + if (hv.type_ == kNilType) continue; + CVar key{kIntType}; + key.data_.i = static_cast(j); + TableDelete(tbl, key, IntKeyHash(static_cast(j))); + tbl->arr_[j - 1] = hv; + } + while (tbl->count_ != 0) { + const int64_t nk2 = static_cast(tbl->arr_size_) + 1; + const CVar hv = TableHashGetInt(tbl, nk2); + if (hv.type_ == kNilType) break; + CVar key{kIntType}; + key.data_.i = nk2; + TableDelete(tbl, key, IntKeyHash(nk2)); + if (tbl->arr_size_ == tbl->arr_cap_) TableArrGrow(s, tbl); + tbl->arr_[tbl->arr_size_++] = hv; + } + return true; +} + +// 整数键 k 要插入已写满的哈希部分前调用；返回 true 表示 k 已写入数组。 +bool TableArrResizeInsert(State *s, VarTable *tbl, int64_t k, CVar v) { + if (tbl->spec_set) return false; + const bool full = tbl->bucket_count_ == 0 ? tbl->count_ >= VarTable::QUICK_DATA_SIZE : (tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == VarTable::INVALID_INDEX); + if (!full) return false; + if (!TableArrTryResize(s, tbl, k)) return false; + return TableArrSetInt(s, tbl, k, v); +} + }// namespace bool TableHelper::VarKeyEqualInt(CVar k, int64_t idx) { @@ -425,6 +543,13 @@ void TableHelper::ForEachKV(CVar tbl, const std::functionarr_size_; ++i) { + if (t->arr_[i].type_ == static_cast(VarType::Nil)) continue; + CVar key{static_cast(VarType::Int)}; + key.data_.i = static_cast(i) + 1; + fn(key, t->arr_[i]); + } + if (t->bucket_count_ == 0) { for (uint32_t i = 0; i < t->count_; ++i) { const auto &qd = t->quick_data_[i]; @@ -466,6 +591,7 @@ int64_t TableHelper::GetTableLen(CVar tbl) { CVar TableHelper::GetTableInt(State *s, CVar tbl, int64_t idx) { if (tbl.type_ != static_cast(VarType::Table) || !tbl.data_.t) return CVar{static_cast(VarType::Nil)}; VarTable *t = tbl.data_.t; + if (static_cast(idx) - 1 < t->arr_size_) return t->arr_[idx - 1]; if (t->spec_get) { using SpecGetFn = CVar (*)(VarTable *, CVar, bool *); @@ -523,6 +649,8 @@ CVar TableHelper::GetTable(State *s, CVar tbl, CVar key) { if (finish) return r; } + if (key.type_ == kIntType && static_cast(key.data_.i) - 1 < t->arr_size_) return t->arr_[key.data_.i - 1]; + if (t->spec_count > 0 && t->spec_vals && t->spec_keys) { for (uint32_t i = 0; i < t->spec_count; ++i) { if (VarKeyEqual(t->spec_keys[i], key)) return t->spec_vals[i]; @@ -630,6 +758,10 @@ void TableHelper::SetTableInt(State *s, CVar tbl, int64_t idx, CVar val) { // 走与 JIT 侧 FlSetTableInt 相同的哈希插入与扩容路径。此前 quick_data_ 的 8 个槽用满后 // 会把整数键 std::to_string 成十进制字符串再按 StringId 存入：JIT 侧按 VAR_INT 键查找 // 时永远匹配不上，于是 table.move 等原生函数写入的第 9 个及之后的元素全部丢失。 + if (TableArrSetInt(s, t, idx, val)) { + SeqNoteIntSet(t, idx, val.type_ == kNilType); + return; + } CVar key{static_cast(VarType::Int)}; key.data_.i = idx; const uint32_t hash = IntKeyHash(idx); @@ -659,6 +791,10 @@ void TableHelper::SetTable(State *s, CVar tbl, CVar key, CVar val) { if (finish) return; } + if (key.type_ == kIntType && TableArrSetInt(s, t, key.data_.i, val)) { + SeqNoteIntSet(t, key.data_.i, val.type_ == kNilType); + return; + } const uint32_t hash = VarKeyHash(key); if (val.type_ == kNilType) { TableDelete(t, key, hash); @@ -925,7 +1061,7 @@ void RegisterTableLibraryApi(State *s) { int64_t icount = static_cast(count); bool same_table = (a1.type_ == static_cast(VarType::Table) && a2.type_ == static_cast(VarType::Table) && a1.data_.t == a2.data_.t); // 空目标表预扩容：避免 1→2→4→… 反复 rehash（大 n 时常数项明显） - if (!same_table && a2.data_.t->count_ == 0 && icount > 8) { + if (!same_table && a2.data_.t->count_ == 0 && icount > 8 && t != static_cast(a2.data_.t->arr_size_) + 1) { TableRehashTo(state, a2.data_.t, static_cast(icount)); } if (!same_table || t <= f || t > e) { diff --git a/src/state/fakelua.cpp b/src/state/fakelua.cpp index 83ea662..00a5c8d 100644 --- a/src/state/fakelua.cpp +++ b/src/state/fakelua.cpp @@ -293,7 +293,7 @@ static void VarToVi(State *state, const CVar &src, VarInterface *dst) { const auto table = var_val.GetTable(); const uint32_t count = table->count_; std::vector> kvs; - kvs.reserve(table->spec_count + count); + kvs.reserve(table->spec_count + table->arr_size_ + count); const auto &new_func = GetVarInterfaceNewFunc(state); auto alloc_vi = [&new_func]() -> VarInterface * { return new_func ? new_func() : new SimpleVarImpl(); }; @@ -308,6 +308,17 @@ static void VarToVi(State *state, const CVar &src, VarInterface *dst) { kvs.emplace_back(key_item, val_item); } } + for (uint32_t i = 0; i < table->arr_size_; ++i) { + const auto &av = AsVar(table->arr_[i]); + if (av.Type() == VarType::Nil) { + continue; + } + auto key_item = alloc_vi(); + auto val_item = alloc_vi(); + key_item->ViSetInt(static_cast(i) + 1); + VarToVi(state, table->arr_[i], val_item); + kvs.emplace_back(key_item, val_item); + } if (const uint32_t *al = table->active_list_; al == nullptr) { for (uint32_t i = 0; i < count; ++i) { const auto &e = table->quick_data_[i]; diff --git a/src/var/var_table.h b/src/var/var_table.h index fb9e8c6..00faae6 100644 --- a/src/var/var_table.h +++ b/src/var/var_table.h @@ -40,6 +40,11 @@ struct VarTable { // 需要重算——因此把 VarTable 整体清零的分配路径天然落在安全的重算分支上。 uint32_t seq_len_valid_; int64_t seq_len_; + // 数组部分：整数键 1..arr_size_ 只存放在 arr_ 中（允许 nil 空洞），哈希部分不含 + // [1, arr_size_+1] 内的整数键。arr_size_ 只增不减。必须与 c_runtime_header.h 一致。 + CVar *arr_; + uint32_t arr_size_; + uint32_t arr_cap_; }; }// namespace fakelua diff --git a/test/lua/table/test_table_array_part.lua b/test/lua/table/test_table_array_part.lua new file mode 100644 index 0000000..29c2d96 --- /dev/null +++ b/test/lua/table/test_table_array_part.lua @@ -0,0 +1,87 @@ +local function checksum(t) + local s = 0 + local n = 0 + for k, v in pairs(t) do + if type(k) == "number" then + s = s + k * 31 + v + else + s = s + 7 + end + n = n + 1 + end + return s * 1000 + n +end + +function test_table_array_part() + local total = 0 + + -- 顺序追加与 # / t[#t+1] + local a = {} + for i = 1, 100 do a[#a + 1] = i * 2 end + total = total + checksum(a) + #a + + -- 逆序填充：先进哈希，最后一个键到位时整体迁入数组 + local b = {} + for i = 50, 1, -1 do b[i] = i end + total = total + checksum(b) + #b + + -- 从 2 开始填充（Lua 风格数组部分重哈希） + local c = {} + for i = 2, 200 do c[i] = i end + total = total + checksum(c) + c[1] = 1 + total = total + checksum(c) + #c + + -- 尾部置 nil 后再追加 + local d = {} + for i = 1, 20 do d[i] = i end + d[20] = nil + d[19] = nil + total = total + checksum(d) + #d + d[#d + 1] = 500 + total = total + checksum(d) + #d + + -- 中间置 nil：遍历跳过空洞，# 取连续前缀 + local e = {} + for i = 1, 10 do e[i] = i end + e[5] = nil + total = total + checksum(e) + e[5] = 55 + total = total + checksum(e) + #e + + -- pairs 中清空整张表 + local f = {} + for i = 1, 30 do f[i] = i end + f.x = 1 + for k, _ in pairs(f) do f[k] = nil end + total = total + checksum(f) + #f + + -- 混合键、0 与负数键、稀疏键 + local g = { 10, 20, 30, x = 1 } + g[0] = 5 + g[-1] = 6 + g[1000000] = 7 + g[4] = 40 + g[5] = 50 + g[2.0] = 21 + total = total + checksum(g) + #g + + -- table.insert / table.remove + local h = {} + for i = 1, 40 do table.insert(h, i) end + table.insert(h, 1, 99) + table.remove(h) + table.remove(h, 1) + total = total + checksum(h) + #h + + -- 稀疏后补齐 + local m = {} + m[3] = 3 + m[5] = 5 + m[1] = 1 + m[2] = 2 + m[4] = 4 + total = total + checksum(m) + #m + + return total +end diff --git a/test/test_table.cpp b/test/test_table.cpp index ad6cdf8..72f3882 100644 --- a/test/test_table.cpp +++ b/test/test_table.cpp @@ -20,6 +20,21 @@ TEST(test_table, test_table_insert_remove) { FakeluaDeleteState(s); } +TEST(test_table, test_table_array_part) { + State *s = FakeluaNewState(); + ASSERT_NE(s, nullptr); + CompileConfig config; + + for (auto jit_type: AllJitTypes()) { + CompileFile(s, "./table/test_table_array_part.lua", config); + int64_t res = 0; + Call(s, jit_type, "test_table_array_part", res); + EXPECT_EQ(res, 32535312104LL); + } + + FakeluaDeleteState(s); +} + TEST(test_table, test_table_concat) { State *s = FakeluaNewState(); ASSERT_NE(s, nullptr); From e32a9f3727682ac0e14bc0eddc508ecae0102157 Mon Sep 17 00:00:00 2001 From: esrrhs Date: Sun, 11 Oct 2026 21:05:43 +0800 Subject: [PATCH 2/2] feat(table): optimize array resize fallback, expand test coverage, and update benchmarks - C runtime & native runtime: update FlArrResizeInsert / TableArrResizeInsert to insert into vacated hash slots when keys do not fall into the newly expanded array, avoiding degenerate rehashes - Tests: expand test_table_array_part.lua with comprehensive coverage for table.move overlapping copies, float-int key normalization, 512-item boundary scaling, sparse hole filling, table.create, and unpack/pack - Tests: add native C++ unit tests in test_table.cpp covering reverse insertions in quick_data/bucket mode and nil-hole export conversion - Docs: update benchmark READMEs with latest measurements and observations reflecting array part improvements --- benchmark/README.md | 46 +++++++------- benchmark/README.zh.md | 46 +++++++------- src/compile/c_runtime_header.h | 24 +++++-- src/native/table/native_table.cpp | 23 ++++++- test/lua/table/test_table_array_part.lua | 79 +++++++++++++++++++++++- test/test_table.cpp | 44 ++++++++++++- 6 files changed, 204 insertions(+), 58 deletions(-) diff --git a/benchmark/README.md b/benchmark/README.md index 9b3008e..0501e8e 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -2,9 +2,7 @@ # Benchmark Results -This file records results of running `bench_mark` compiled in **Release mode** (`-O3 -DNDEBUG`) locally. It covers **51 Lua performance scenarios across 6 categories**, each with C++ / Lua 5.4 / FakeLua TCC / FakeLua GCC / FakeLua INTERP (bytecode interpreter). Analysis below splits into **interpreter vs Lua 5.4** (this machine, 2026-09-16) and **GCC JIT vs Lua / C++** (previous machine, 2026-08-14). - -These benchmark results predate the table array-part implementation; table-performance figures and notes below are historical baselines, not measurements of the current code. +This file records results of running `bench_mark` compiled in **Release mode** (`-O3 -DNDEBUG`) locally. It covers **51 Lua performance scenarios across 6 categories**, each with C++ / Lua 5.4 / FakeLua TCC / FakeLua GCC / FakeLua INTERP (bytecode interpreter). Analysis below splits into **interpreter vs Lua 5.4** and **GCC JIT vs Lua / C++**. Table benchmarks include latest measurements reflecting the Lua-style contiguous array part (`VarTable::arr_`). ## Running @@ -80,16 +78,16 @@ Largest parameter per scenario: | Scenario | Param | INTERP vs Lua | INTERP / Lua time | Notes | |----------|-------|---------------|-------------------|-------| -| TableInsert | n=5K | 0.29x | 3.5x | No array part | -| TableRemove | n=5K | 0.41x | 2.4x | | -| TableConcat | n=1000 | 1.05x | 0.95x | On par (C concat) | -| TablePack | n=1 | 1.12x | 0.90x | | -| TableMove | n=5K | 0.38x | 2.6x | | -| TableSort | n=1000 | 1.87x | 0.54x | C `table.sort` | -| TableCreate | n=5K | 0.30x | 3.3x | | -| HashInsert | n=1000 | 1.33x | 0.75x | Arena vs Lua GC | -| HashLookup | n=1000 | 1.13x | 0.89x | | -| NestedTable | n=10K | 0.25x | 4.0x | Repeated `GETTABLE` | +| TableInsert | n=5K | 0.38x | 2.6x | With array part (improved from 3.5x) | +| TableRemove | n=5K | 0.55x | 1.8x | With array part (improved from 2.4x) | +| TableConcat | n=1000 | 1.31x | 0.76x | Faster than Lua (C concat) | +| TablePack | n=1 | 1.66x | 0.60x | Faster than Lua | +| TableMove | n=5K | 0.75x | 1.3x | With array part (improved from 2.6x) | +| TableSort | n=1000 | 3.17x | 0.32x | C `table.sort` (3.2x faster than Lua) | +| TableCreate | n=5K | 0.71x | 1.4x | With array part (improved from 3.3x) | +| HashInsert | n=1000 | 1.53x | 0.65x | Arena vs Lua GC | +| HashLookup | n=1000 | 1.17x | 0.85x | | +| NestedTable | n=10K | 0.42x | 2.4x | With array part (improved from 4.0x) | ### Function Calls (function) @@ -127,7 +125,7 @@ Largest parameter per scenario: 3. **Tail recursion is the outlier (34×)**: Lua 5.4 turns `return f(...)` into a loop. INTERP does not; n=5000 is 5000 nested C frames (and overflows the default 8 MiB stack). -4. **In these pre-array-part measurements, table loops were ~3–4× slower** (BubbleSort, Vector3, TableInsert, NestedTable). At the time, `VarTable` used hash-only storage while Lua used an array part. +4. **Table loops and operations with array part**: With the contiguous array-part implementation, table loops and operations are significantly faster. In the bytecode interpreter, table loop slowdown vs Lua dropped from ~3–4× to ~1.3–2.6× (`table.sort` is 3.2× faster than Lua, `TableConcat` is 1.3× faster, and `TableInsert`/`TableRemove` are substantially improved). 5. **C stdlib work can beat Lua**: `string.lower`/`upper` **6.2×**, `string.len` 2.3×, `table.sort` 1.9×, TableChurn 2.2× (arena). When the opcode loop is not the bottleneck, native helpers plus no-GC allocation win. @@ -194,16 +192,16 @@ The tables below are from a **previous** run on a different machine (AMD EPYC 7K | Scenario | Param | GCC vs Lua | GCC vs C++ | Notes | |----------|-------|-----------|-----------|-------| -| TableInsert | n=5K | **4.0x** | 4.87 | | -| TableRemove | n=5K | **3.2x** | 2.99 | | -| TableConcat | n=1000 | 1.0x | 4.16 | Arena single write | -| TablePack | n=1 | 1.9x | 157 | | -| TableMove | n=5K | 1.0x | 2.84 | CGen `FlTableMove` + empty table pre-grow | -| TableSort | n=1000 | 1.2x | 4.74 | | -| TableCreate | n=5K | 1.1x | 2.20 | | -| HashInsert | n=1000 | 2.0x | 0.88 | | -| HashLookup | n=1000 | 1.9x | 0.45 | | -| NestedTable | n=10K | 3.4x | 1.39 | Outer table pointer offset traversal | +| TableInsert | n=5K | **9.8x** | 16.5 | With array part (up from 4.0x) | +| TableRemove | n=5K | **12.2x** | 29.5 | With array part (up from 3.2x) | +| TableConcat | n=1000 | 1.4x | 15.0 | Arena single write | +| TablePack | n=1 | 3.7x | 1229 | | +| TableMove | n=5K | 1.9x | 33.1 | Array-aware move | +| TableSort | n=1000 | 4.6x | 4.62 | C `table.sort` | +| TableCreate | n=5K | 2.7x | 14.7 | Pre-allocated array part | +| HashInsert | n=1000 | 2.4x | 1.34 | | +| HashLookup | n=1000 | 2.4x | 0.82 | Faster than handwritten C++ map | +| NestedTable | n=10K | 3.8x | 10.0 | Array part integer indexing | ### Function Calls (function) diff --git a/benchmark/README.zh.md b/benchmark/README.zh.md index 2ab0523..a0ee3e0 100644 --- a/benchmark/README.zh.md +++ b/benchmark/README.zh.md @@ -1,8 +1,6 @@ # 性能基准测试结果 -本文件记录在本地以 **Release 模式**（`-O3 -DNDEBUG`）编译运行 `bench_mark` 的结果。覆盖 **6 大类共 51 个 Lua 性能场景**，每个场景均实现 C++ / Lua 5.4 / FakeLua TCC / FakeLua GCC / FakeLua INTERP（字节码解释器）横向对比。下面分析分成两块：**解释器 vs Lua 5.4**（本机，2026-09-16）和 **GCC JIT vs Lua / C++**（上一台机器，2026-08-14）。 - -以下基准结果早于表数组部分的实现；表性能数据和说明是历史基线，不代表当前代码的测量结果。 +本文件记录在本地以 **Release 模式**（`-O3 -DNDEBUG`）编译运行 `bench_mark` 的结果。覆盖 **6 大类共 51 个 Lua 性能场景**，每个场景均实现 C++ / Lua 5.4 / FakeLua TCC / FakeLua GCC / FakeLua INTERP（字节码解释器）横向对比。下面分析分成两块：**解释器 vs Lua 5.4** 和 **GCC JIT vs Lua / C++**。表操作场景已更新为引入连续整数键数组段（`VarTable::arr_`）后的最新测量数据。 ## 运行命令 @@ -78,16 +76,16 @@ build/bin/bench_mark --benchmark_repetitions=1 --benchmark_report_aggregates_onl | 场景 | 参数 | INTERP vs Lua | INTERP / Lua 耗时 | 备注 | |------|------|---------------|-------------------|------| -| TableInsert | n=5K | 0.29x | 3.5x | 无 array part | -| TableRemove | n=5K | 0.41x | 2.4x | | -| TableConcat | n=1000 | 1.05x | 0.95x | 持平（C 拼接） | -| TablePack | n=1 | 1.12x | 0.90x | | -| TableMove | n=5K | 0.38x | 2.6x | | -| TableSort | n=1000 | 1.87x | 0.54x | C `table.sort` | -| TableCreate | n=5K | 0.30x | 3.3x | | -| HashInsert | n=1000 | 1.33x | 0.75x | arena vs Lua GC | -| HashLookup | n=1000 | 1.13x | 0.89x | | -| NestedTable | n=10K | 0.25x | 4.0x | 反复 `GETTABLE` | +| TableInsert | n=5K | 0.38x | 2.6x | 包含数组段优化（原 3.5x） | +| TableRemove | n=5K | 0.55x | 1.8x | 包含数组段优化（原 2.4x） | +| TableConcat | n=1000 | 1.31x | 0.76x | 快于 Lua（C concat） | +| TablePack | n=1 | 1.66x | 0.60x | 快于 Lua | +| TableMove | n=5K | 0.75x | 1.3x | 包含数组段优化（原 2.6x） | +| TableSort | n=1000 | 3.17x | 0.32x | C `table.sort`（比 Lua 快 3.2 倍） | +| TableCreate | n=5K | 0.71x | 1.4x | 包含数组段优化（原 3.3x） | +| HashInsert | n=1000 | 1.53x | 0.65x | Arena 堆分配 vs Lua GC | +| HashLookup | n=1000 | 1.17x | 0.85x | | +| NestedTable | n=10K | 0.42x | 2.4x | 包含数组段优化（原 4.0x） | ### 函数调用（function） @@ -125,7 +123,7 @@ build/bin/bench_mark --benchmark_repetitions=1 --benchmark_report_aggregates_onl 3. **尾递归是离群点（34 倍）**：Lua 5.4 把 `return f(...)` 收成循环。INTERP 没有；n=5000 是 5000 层 C 栈（默认 8 MiB 会溢出）。 -4. **在这些实现数组部分之前的测量中，表循环大约慢 3–4 倍**（BubbleSort、Vector3、TableInsert、NestedTable）。当时 `VarTable` 只有哈希存储，而 Lua 使用数组部分。 +4. **数组段（Array Part）显著缩小表操作差距**：引入连续整数键数组段后，解释器下表循环和表内置函数性能明显改善，相对 Lua 的耗时从过去的 3–4 倍收窄至 1.3–2.6 倍（`table.sort` 快 3.2 倍，`TableConcat` 快 1.3 倍，`TableInsert`/`TableRemove` 显著优化）。 5. **落到 C 标准库的工作可以快过 Lua**：`string.lower`/`upper` **6.2 倍**、`string.len` 2.3 倍、`table.sort` 1.9 倍、TableChurn 2.2 倍（arena）。操作码循环不是瓶颈时，原生辅助函数加上无 GC 分配会赢。 @@ -192,16 +190,16 @@ build/bin/bench_mark --benchmark_repetitions=1 --benchmark_report_aggregates_onl | 场景 | 参数 | GCC vs Lua | GCC vs C++ | 备注 | |------|------|-----------|-----------|------| -| TableInsert | n=5K | **4.0x** | 4.87 | | -| TableRemove | n=5K | **3.2x** | 2.99 | | -| TableConcat | n=1000 | 1.0x | 4.16 | arena 一次写入 | -| TablePack | n=1 | 1.9x | 157 | | -| TableMove | n=5K | 1.0x | 2.84 | CGen `FlTableMove` + 空表预扩容 | -| TableSort | n=1000 | 1.2x | 4.74 | | -| TableCreate | n=5K | 1.1x | 2.20 | | -| HashInsert | n=1000 | 2.0x | 0.88 | | -| HashLookup | n=1000 | 1.9x | 0.45 | | -| NestedTable | n=10K | 3.4x | 1.39 | 表层指针偏移遍历 | +| TableInsert | n=5K | **9.8x** | 16.5 | 引入数组段（原 4.0x） | +| TableRemove | n=5K | **12.2x** | 29.5 | 引入数组段（原 3.2x） | +| TableConcat | n=1000 | 1.4x | 15.0 | arena 一次写入 | +| TablePack | n=1 | 3.7x | 1229 | | +| TableMove | n=5K | 1.9x | 33.1 | 支持数组段直拷 | +| TableSort | n=1000 | 4.6x | 4.62 | 原生排序 | +| TableCreate | n=5K | 2.7x | 14.7 | 数组段连续填充 | +| HashInsert | n=1000 | 2.4x | 1.34 | | +| HashLookup | n=1000 | 2.4x | 0.82 | 快于原生 C++ map 查找 | +| NestedTable | n=10K | 3.8x | 10.0 | 数组段整数快速索引 | ### 函数调用（function） diff --git a/src/compile/c_runtime_header.h b/src/compile/c_runtime_header.h index b27be25..e8ebeec 100644 --- a/src/compile/c_runtime_header.h +++ b/src/compile/c_runtime_header.h @@ -1053,11 +1053,27 @@ __attribute__((noinline)) static bool FlArrTryResize(VarTable *tbl, int64_t nk) return true; } -/* 整数键 k 要插入已写满的哈希部分前调用；返回 true 表示 k 已写入数组，调用方直接返回。*/ +/* 整数键 k 要插入已写满的哈希部分前调用；返回 true 表示 k 已写入数组或哈希空位，调用方直接返回。*/ static inline bool FlArrResizeInsert(VarTable *tbl, CVar k, CVar v) { if (k.type_ != VAR_INT || tbl->spec_set) { return false; } if (!FlArrTryResize(tbl, k.data_.i)) { return false; } - return FlArrSetInt(tbl, k.data_.i, v); + if (FlArrSetInt(tbl, k.data_.i, v)) { return true; } + uint32_t h = (uint32_t)(k.data_.i ^ (k.data_.i >> 32)); + if (tbl->bucket_count_ == 0) { + if (tbl->count_ < 8) { + tbl->quick_data_[tbl->count_].key = k; + tbl->quick_data_[tbl->count_].val = v; + tbl->quick_data_[tbl->count_].hash = h; + tbl->count_++; + return true; + } + } else { + if (tbl->count_ < tbl->bucket_count_ && tbl->free_list_idx_ != 0xFFFFFFFF) { + FlTableInsertRaw(tbl, k, v, h); + return true; + } + } + return false; } static inline void FlSetTableImpl(CVar t, CVar k, CVar v) { @@ -1076,10 +1092,10 @@ static inline void FlSetTableImpl(CVar t, CVar k, CVar v) { } static inline void FlSetTable(CVar t, CVar k, CVar v) { + k = NORMALIZE_TABLE_KEY(k); FlSetTableImpl(t, k, v); if (LIKELY(t.type_ == VAR_TABLE)) { - CVar __nk = NORMALIZE_TABLE_KEY(k); - if (__nk.type_ == VAR_INT) { FlSeqNoteIntSet(t.data_.t, __nk.data_.i, v.type_ == VAR_NIL); } + if (k.type_ == VAR_INT) { FlSeqNoteIntSet(t.data_.t, k.data_.i, v.type_ == VAR_NIL); } } } diff --git a/src/native/table/native_table.cpp b/src/native/table/native_table.cpp index 2a8e730..863fde1 100644 --- a/src/native/table/native_table.cpp +++ b/src/native/table/native_table.cpp @@ -507,13 +507,32 @@ bool TableArrTryResize(State *s, VarTable *tbl, int64_t nk) { return true; } -// 整数键 k 要插入已写满的哈希部分前调用；返回 true 表示 k 已写入数组。 +// 整数键 k 要插入已写满的哈希部分前调用；返回 true 表示 k 已写入数组或哈希空位。 bool TableArrResizeInsert(State *s, VarTable *tbl, int64_t k, CVar v) { if (tbl->spec_set) return false; const bool full = tbl->bucket_count_ == 0 ? tbl->count_ >= VarTable::QUICK_DATA_SIZE : (tbl->count_ >= tbl->bucket_count_ || tbl->free_list_idx_ == VarTable::INVALID_INDEX); if (!full) return false; if (!TableArrTryResize(s, tbl, k)) return false; - return TableArrSetInt(s, tbl, k, v); + if (TableArrSetInt(s, tbl, k, v)) return true; + CVar key{kIntType}; + key.data_.i = k; + const uint32_t hash = IntKeyHash(k); + if (tbl->bucket_count_ == 0) { + if (tbl->count_ < VarTable::QUICK_DATA_SIZE) { + auto &qd = tbl->quick_data_[tbl->count_]; + static_cast(qd.key) = key; + static_cast(qd.val) = v; + qd.hash = hash; + tbl->count_++; + return true; + } + } else { + if (tbl->count_ < tbl->bucket_count_ && tbl->free_list_idx_ != VarTable::INVALID_INDEX) { + TableInsertRaw(tbl, key, v, hash); + return true; + } + } + return false; } }// namespace diff --git a/test/lua/table/test_table_array_part.lua b/test/lua/table/test_table_array_part.lua index 29c2d96..4a6c2b4 100644 --- a/test/lua/table/test_table_array_part.lua +++ b/test/lua/table/test_table_array_part.lua @@ -3,13 +3,13 @@ local function checksum(t) local n = 0 for k, v in pairs(t) do if type(k) == "number" then - s = s + k * 31 + v + s = s + math.floor(k) * 31 + math.floor(v) else s = s + 7 end n = n + 1 end - return s * 1000 + n + return math.floor(s * 1000 + n) end function test_table_array_part() @@ -83,5 +83,78 @@ function test_table_array_part() m[4] = 4 total = total + checksum(m) + #m - return total + -- table.move 数组段自移动与跨表移动 + local mv_src = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } + table.move(mv_src, 1, 5, 6, mv_src) + total = total + checksum(mv_src) + #mv_src + local mv_dst = {} + table.move(mv_src, 1, 10, 1, mv_dst) + total = total + checksum(mv_dst) + #mv_dst + table.move(mv_src, 3, 7, 1, mv_src) + total = total + checksum(mv_src) + #mv_src + + -- 浮点等价键与非整数浮点键 + local flt = {} + flt[1.0] = 100 + flt[2.0] = 200 + flt[1.5] = 150 + flt[2.5] = 250 + total = total + math.floor(flt[1]) + math.floor(flt[2]) + math.floor(flt[1.5]) + math.floor(flt[2.5]) + #flt + total = total + checksum(flt) + #flt + flt[1] = 111 + total = total + math.floor(flt[1.0]) + + -- 大规模连续扩容与截断收缩 + local big = {} + for i = 1, 512 do big[i] = i end + total = total + #big + big[1] + big[512] + for i = 512, 257, -1 do big[i] = nil end + total = total + #big + for i = 257, 512 do big[i] = i * 2 end + total = total + #big + checksum(big) + + -- 阶梯跳跃打洞再逆向补齐 + local sk = {} + sk[1] = 10 + sk[4] = 40 + sk[8] = 80 + sk[16] = 160 + total = total + #sk + sk[2] = 20 + sk[3] = 30 + total = total + #sk + for i = 5, 7 do sk[i] = i * 10 end + total = total + #sk + for i = 9, 15 do sk[i] = i * 10 end + total = total + #sk + checksum(sk) + + -- table.create 预分配数组配合数组操作 + local tc = table.create(30, 7) + total = total + #tc + tc[1] + tc[30] + tc[15] = 99 + table.insert(tc, 100) + total = total + #tc + tc[31] + checksum(tc) + + -- table.pack / table.unpack + local pk = table.pack(11, 22, 33, 44, 55) + local u1, u2, u3, u4, u5 = table.unpack(pk, 1, 5) + total = total + u1 + u2 + u3 + u4 + u5 + pk.n + checksum(pk) + + -- ipairs 遍历数组段与遇到空洞截断 + local ip_tbl = { 10, 20, 30, 40, 50 } + ip_tbl[3] = nil + local ip_sum = 0 + for idx, val in ipairs(ip_tbl) do + ip_sum = ip_sum + idx * 100 + val + end + total = total + ip_sum + + -- 边界极值键与负数键 + local ext = { 1, 2, 3 } + ext[0] = 99 + ext[-10] = 88 + ext[2147483647] = 77 + total = total + #ext + ext[1] + ext[2] + ext[3] + ext[0] + ext[-10] + ext[2147483647] + + return math.tointeger(total) or math.floor(total) end diff --git a/test/test_table.cpp b/test/test_table.cpp index 72f3882..1d60de6 100644 --- a/test/test_table.cpp +++ b/test/test_table.cpp @@ -1,7 +1,9 @@ #include #include "fakelua.h" +#include "native/table/native_table.h" #include "test_jit.h" +#include "var/var.h" using namespace fakelua; @@ -29,12 +31,52 @@ TEST(test_table, test_table_array_part) { CompileFile(s, "./table/test_table_array_part.lua", config); int64_t res = 0; Call(s, jit_type, "test_table_array_part", res); - EXPECT_EQ(res, 32535312104LL); + EXPECT_EQ(res, 36864326318LL); } FakeluaDeleteState(s); } +TEST(test_table, test_table_native_array_part) { + State *s = FakeluaNewState(); + ASSERT_NE(s, nullptr); + + // 1. 测试直接调用 TableHelper::SetTableInt，逆序写入触发 TableArrResizeInsert -> TableArrTryResize + CVar tbl = table::TableHelper::CreateTable(s); + for (int64_t i = 8; i >= 2; --i) { + table::TableHelper::SetTableInt(s, tbl, i, Var(static_cast(i * 10))); + } + table::TableHelper::SetTableInt(s, tbl, 100, Var(int64_t{1000})); + table::TableHelper::SetTableInt(s, tbl, 1, Var(int64_t{10})); + + EXPECT_EQ(table::TableHelper::GetTableInt(s, tbl, 1).data_.i, 10); + EXPECT_EQ(table::TableHelper::GetTableInt(s, tbl, 2).data_.i, 20); + EXPECT_EQ(table::TableHelper::GetTableInt(s, tbl, 8).data_.i, 80); + EXPECT_EQ(table::TableHelper::GetTableInt(s, tbl, 100).data_.i, 1000); + EXPECT_EQ(table::TableHelper::GetTableLen(tbl), 8); + + // 2. 桶模式下的 TableArrResizeInsert + CVar tbl2 = table::TableHelper::CreateTable(s); + for (int64_t i = 30; i >= 2; --i) { + table::TableHelper::SetTableInt(s, tbl2, i, Var(static_cast(i))); + } + table::TableHelper::SetTableInt(s, tbl2, 1, Var(int64_t{1})); + EXPECT_EQ(table::TableHelper::GetTableLen(tbl2), 30); + EXPECT_EQ(table::TableHelper::GetTableInt(s, tbl2, 1).data_.i, 1); + EXPECT_EQ(table::TableHelper::GetTableInt(s, tbl2, 30).data_.i, 30); + + // 3. 带数组空洞的表导出到 VarInterface（覆盖 fakelua.cpp 中 av.Type() == VarType::Nil） + CVar tbl3 = table::TableHelper::CreateTable(s); + table::TableHelper::SetTableInt(s, tbl3, 1, Var(int64_t{100})); + table::TableHelper::SetTableInt(s, tbl3, 2, Var(int64_t{200})); + table::TableHelper::SetTableInt(s, tbl3, 2, Var()); + VarInterface *vi = inter::FakeluaToNativeObj(s, tbl3); + ASSERT_NE(vi, nullptr); + delete vi; + + FakeluaDeleteState(s); +} + TEST(test_table, test_table_concat) { State *s = FakeluaNewState(); ASSERT_NE(s, nullptr);