LuaJIT2.1 和 Lua5.4.8 性能对比

说明

最近在学习 LuaJIT，想看看把它接入到项目中使用，会提高多大的性能。

今天抽时间，简单地测试了一下 LuaJIT 2.2 和 Lua5.4.8 的性能。

测试平台：

• 系统：Windows 10 WSL
• CPU：Intel® Core™ i7-8700 CPU @ 3.20GHz 3.19 GHz
• 内存：48.0 GB

下面测试结果只是我简单测试的结果，仅供参考。
相关代码在最后面。

综合性能对比分析

第一组测试（详细性能对比）

测试项目	Lua 5.4	LuaJIT	性能提升
Fibonacci(30) 递归	0.0515秒	0.0095秒	5.4倍
数学操作(10万次)	0.0125秒	0.0022秒	5.7倍
字符串操作	0.0033秒	0.0043秒	0.8倍
表操作(10万)	0.0797秒	0.0322秒	2.5倍

第二组测试（深度分析）

测试规模/类型	Lua 5.4	LuaJIT	性能提升
100万次循环	0.0041秒	0.0010秒	4.1倍
500万次循环	0.0204秒	0.0051秒	4.0倍
1000万次循环	0.0407秒	0.0102秒	4.0倍
浮点运算(100万)	0.0298秒	0.0056秒	5.3倍
整数操作	0.0062秒	0.0010秒	6.2倍
浮点操作	0.0069秒	0.0010秒	6.9倍
顺序访问	0.0020秒	0.0006秒	3.3倍
随机访问	0.0034秒	0.0010秒	3.4倍

关键说明

1. 稳定的性能提升

LuaJIT在所有数值计算任务上都展现了4-7倍的性能提升，这个倍数很稳定，说明JIT优化效果是可预测的。

2. 规模无关的优化效果

从100万到1000万次循环，性能提升倍数保持在4倍左右，说明LuaJIT的优化效果不受问题规模影响。

3. 内存使用效率

• Lua 5.4: 1048.76 KB
• LuaJIT: 563.17 KB

LuaJIT使用了约**46%**更少的内存，这可能因为：

• 更高效的对象表示
• 不同的垃圾回收策略
• JIT编译后的代码更紧凑

4. 类型统一优化

在LuaJIT中，整数和浮点操作的性能几乎相同（都是0.0010秒），这说明JIT编译器成功地进行了类型特化优化。

5. 内存访问模式优化

LuaJIT对顺序访问和随机访问都有显著优化，但顺序访问的优势更明显。

6. JIT预热效果

有趣的是，这次测试中JIT预热效果不明显（1.01倍），这可能因为：

• 测试代码相对简单，很快就被优化了
• 测试规模足够大，预热时间相对较短

相关代码

测试1

-- detailed_comparison.lua
print("=== Detailed Performance Comparison ===")
print("Lua Version:", _VERSION)
print("Engine:", jit and jit.version or "Standard Lua Interpreter")
print()local function benchmark(name, func, ...)collectgarbage("collect")local start = os.clock()local result = func(...)local elapsed = os.clock() - startprint(string.format("%-30s: %8.4f seconds", name, elapsed))return elapsed
end-- 避免溢出的斐波那契测试
local function safe_fibonacci(n)if n <= 1 then return n endlocal a, b = 0, 1for i = 2, n doa, b = b, a + b-- 检查是否即将溢出if b > 1e15 thenreturn b  -- 提前返回避免溢出endendreturn b
end-- 不同规模的递归测试
local function fib_recursive(n)if n <= 1 then return n endreturn fib_recursive(n-1) + fib_recursive(n-2)
end-- 数学计算密集
local function math_intensive(n)local sum = 0for i = 1, n dosum = sum + math.sin(i) * math.cos(i) + math.sqrt(i)endreturn sum
end-- 字符串操作
local function string_operations(n)local result = ""for i = 1, n doresult = result .. tostring(i)if #result > 100000 then break end  -- 避免内存问题endreturn #result
end-- table密集操作
local function table_intensive(n)local t = {}for i = 1, n dot[i] = {x = i, y = i * 2, data = "item" .. i}endlocal sum = 0for i = 1, n dosum = sum + t[i].x + t[i].yendreturn sum
endprint("Running benchmarks...")-- 适中的测试规模
benchmark("Fibonacci(30) recursive", fib_recursive, 30)
benchmark("Safe Fibonacci(100000)", safe_fibonacci, 100000)
benchmark("Math operations (100K)", math_intensive, 100000)
benchmark("String operations", string_operations, 5000)
benchmark("Table operations (100K)", table_intensive, 100000)-- 显示内存使用
collectgarbage("collect")
print(string.format("\nMemory usage: %.2f KB", collectgarbage("count")))-- JIT特定信息
if jit thenprint("\nJIT Information:")print("Status:", jit.status())print("Architecture:", jit.arch)-- 显示编译的trace数量local traces = 0for i = 1, 1000 doif jit.util and jit.util.traceinfo and jit.util.traceinfo(i) thentraces = traces + 1endendif traces > 0 thenprint("Compiled traces:", traces)end
end

测试代码2：

-- deep_analysis.lua
print("=== Deep Performance Analysis ===")
print("Engine:", jit and jit.version or ("Standard " .. _VERSION))
print()local function benchmark_with_analysis(name, func, iterations, ...)-- 预热运行func(...)-- 多次测试求平均值local times = {}for i = 1, iterations docollectgarbage("collect")local start = os.clock()local result = func(...)local elapsed = os.clock() - starttimes[i] = elapsedend-- 计算统计信息local total = 0local min_time = times[1]local max_time = times[1]for i = 1, iterations dototal = total + times[i]if times[i] < min_time then min_time = times[i] endif times[i] > max_time then max_time = times[i] endendlocal avg_time = total / iterationsprint(string.format("%-25s: avg=%.4fs, min=%.4fs, max=%.4fs", name, avg_time, min_time, max_time))return avg_time
end-- 不同规模的循环测试
local function loop_test(n)local sum = 0for i = 1, n dosum = sum + iendreturn sum
end-- 浮点数密集计算
local function float_intensive(n)local x = 1.0for i = 1, n dox = x * 1.000001x = math.sqrt(x)endreturn x
end-- 整数vs浮点数操作
local function integer_ops(n)local sum = 0for i = 1, n dosum = sum + (i * 2)  -- 整数运算endreturn sum
endlocal function float_ops(n)local sum = 0.0for i = 1, n dosum = sum + (i * 2.0)  -- 浮点运算endreturn sum
end-- 表访问模式测试
local function sequential_access(n)local t = {}for i = 1, n dot[i] = iendlocal sum = 0for i = 1, n dosum = sum + t[i]endreturn sum
endlocal function random_access(n)local t = {}for i = 1, n dot[i] = iendlocal sum = 0for i = 1, n dolocal idx = (i * 17 + 31) % n + 1  -- 伪随机访问sum = sum + t[idx]endreturn sum
endprint("Multiple runs for statistical accuracy:")
print()-- 不同规模的测试
local sizes = {1000000, 5000000, 10000000}
for _, size in ipairs(sizes) doprint(string.format("=== Scale: %d operations ===", size))benchmark_with_analysis("Loop " .. size, loop_test, 3, size)if size <= 1000000 then  -- 避免浮点运算太慢benchmark_with_analysis("Float " .. size, float_intensive, 3, size)endprint()
endprint("=== Data Type Comparison ===")
benchmark_with_analysis("Integer operations", integer_ops, 5, 1000000)
benchmark_with_analysis("Float operations", float_ops, 5, 1000000)
print()print("=== Memory Access Patterns ===")
benchmark_with_analysis("Sequential access", sequential_access, 3, 100000)
benchmark_with_analysis("Random access", random_access, 3, 100000)
print()-- JIT特定分析
if jit thenprint("=== JIT Warmup Analysis ===")local function warmup_test(n)local sum = 0for i = 1, n dosum = sum + math.sin(i) * math.cos(i)endreturn sumend-- 冷启动local start = os.clock()warmup_test(100000)local cold_time = os.clock() - start-- 预热后local start2 = os.clock()warmup_test(100000)local warm_time = os.clock() - start2print(string.format("Cold start: %.4fs", cold_time))print(string.format("After warmup: %.4fs", warm_time))print(string.format("Warmup speedup: %.2fx", cold_time / warm_time))
end

.
.
上述测试结果只是我简单测试的结果，仅供参考（图片AI生成）
.
.