Skip to content

Commit bbba36c

Browse files
CppCXYCppCXY
committed
update performance report
1 parent ccb0607 commit bbba36c

File tree

3 files changed

+117
-461
lines changed

3 files changed

+117
-461
lines changed

‎PERFORMANCE_REPORT.md‎

Lines changed: 64 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -1,86 +1,87 @@
11
# Lua-RS Performance Report
22

3-
> **Last Updated**: November 29, 2025
3+
> **Last Updated**: November 30, 2025
44
> **Test Environment**: Windows 11, AMD Ryzen 7 5800X, Rust 1.89.0
55
> **Lua-RS Version**: main
66
> **Native Lua Version**: Lua 5.4.6
77
88
## Executive Summary
99

10-
Lua-RS has achieved **production-ready correctness** with **252/252 tests passing (100%)**. The interpreter delivers **40-104% of native Lua 5.4 performance** across most operations, with excellent performance in control flow and arithmetic operations.
10+
Lua-RS has achieved **production-ready correctness** with **302/302 tests passing (100%)**. The interpreter delivers **40-100%+ of native Lua 5.4 performance** across most operations, with excellent performance in arithmetic and control flow operations.
1111

1212
### Key Performance Highlights
1313

1414
🏆 **Excellent Performance (>90% of native)**:
15-
- **While loop**: **104%** of native (142.52 M/s vs 136.99 M/s) - **Faster than native!**
16-
- **Integer addition**: **96%** of native (246.04 M/s vs 256.41 M/s)
17-
- **Nested loops**: **93%** of native (232.67 M/s vs 250.00 M/s)
15+
- **Integer addition**: **101%** of native (251.89 M/s vs 250.00 M/s) - **Faster than native!**
16+
- **Float multiplication**: **99%** of native (248.50 M/s vs 250.00 M/s)
17+
- **Table insertion**: **101%** of native (71.99 M/s vs 71.43 M/s) - **Faster than native!**
18+
- **Nested loops**: **97%** of native (243.30 M/s vs 250.00 M/s)
1819

1920
🎯 **Good Performance (60-90% of native)**:
20-
- **Float multiplication**: **77%** (168.43 M/s vs 217.39 M/s)
21-
- **Hash table insertion**: **77%** (0.023s vs 0.030s)
22-
- **If-else control**: **75%** (89.21 M/s vs 119.05 M/s)
23-
- **Table insertion**: **70%** (46.40 M/s vs 66.67 M/s)
24-
- **Mixed operations**: **68%** (106.59 M/s vs 156.25 M/s)
25-
- **Repeat-until**: **66%** (113.66 M/s vs 172.41 M/s)
26-
- **string.gsub**: **66% faster** (0.101s vs 0.152s)
27-
- **String concatenation**: **61%** (2775 K/s vs 4545 K/s)
28-
29-
📊 **Acceptable Performance (40-60% of native)**:
30-
- **Table access**: **49%** (81.39 M/s vs 166.67 M/s)
31-
- **Simple function call**: **43%** (23.88 M/s vs 55.56 M/s)
32-
- **ipairs iteration**: **41%** (5.227s vs 2.122s)
33-
- **Vararg function**: **41%** (1.48 M/s vs 3.60 M/s)
34-
35-
⚠️ **Areas for Optimization (<40% of native)**:
36-
- **string.sub**: **39%** (7769 K/s vs 20000 K/s)
37-
- **Recursive fib(25)**: **36%** (0.011s vs 0.004s)
38-
- **string.find**: **33%** (6568 K/s vs 20000 K/s)
39-
- **Array creation & access**: **26%** (2.94 M/s vs 11.11 M/s)
21+
- **While loop**: **85%** (127.10 M/s vs 149.25 M/s)
22+
- **If-else control**: **84%** (99.71 M/s vs 119.05 M/s)
23+
- **Mixed operations**: **80%** (125.22 M/s vs 156.25 M/s)
24+
- **Table access**: **77%** (128.46 M/s vs 166.67 M/s)
25+
- **Hash table insertion**: **136%** (0.022s vs 0.030s) - **Faster than native!**
26+
- **Repeat-until**: **61%** (114.36 M/s vs 188.68 M/s)
27+
- **String concatenation**: **60%** (2748 K/s vs 4545 K/s)
28+
- **Simple function call**: **59%** (32.77 M/s vs 55.56 M/s)
29+
30+
📊 **Acceptable Performance (30-60% of native)**:
31+
- **Array creation & access**: **45%** (5.10 M/s vs 11.24 M/s)
32+
- **Recursive fib(25)**: **40%** (0.010s vs 0.004s)
33+
- **Vararg function**: **36%** (1.29 M/s vs 3.58 M/s)
34+
- **ipairs iteration**: **31%** (6.785s vs 2.098s)
35+
- **string.sub**: **33%** (8155 K/s vs 25000 K/s)
36+
- **string.find**: **33%** (5553 K/s vs 16666 K/s)
37+
38+
🏆 **Faster than Native**:
39+
- **string.gsub**: **146%** (0.104s vs 0.152s) - **46% faster!**
40+
- **Hash table insertion**: **136%** (0.022s vs 0.030s) - **36% faster!**
4041

4142
---
4243

43-
## Latest Benchmark Results (November 29, 2025)
44+
## Latest Benchmark Results (November 30, 2025)
4445

4546
### Arithmetic Operations
4647
| Operation | Lua-RS | Native Lua | % of Native | Status |
4748
|-----------|--------|-----------|-------------|--------|
48-
| Integer addition | **246.04 M/s** | 256.41 M/s | **96%** | Excellent 🏆 |
49-
| Float multiplication | **168.43 M/s** | 217.39 M/s | **77%** | Good |
50-
| Mixed operations | **106.59 M/s** | 156.25 M/s | **68%** | Good |
49+
| Integer addition | **251.89 M/s** | 250.00 M/s | **101%** | Excellent 🏆 |
50+
| Float multiplication | **248.50 M/s** | 250.00 M/s | **99%** | Excellent 🏆 |
51+
| Mixed operations | **125.22 M/s** | 156.25 M/s | **80%** | Good |
5152

5253
### Function Calls
5354
| Operation | Lua-RS | Native Lua | % of Native | Status |
5455
|-----------|--------|-----------|-------------|--------|
55-
| Simple function call | **23.88 M/s** | 55.56 M/s | **43%** | Acceptable |
56-
| Recursive fib(25) | **0.011s** | 0.004s | **36%** | Needs optimization |
57-
| Vararg function | **1.48 M/s** | 3.60 M/s | **41%** | Acceptable |
56+
| Simple function call | **32.77 M/s** | 55.56 M/s | **59%** | Good |
57+
| Recursive fib(25) | **0.010s** | 0.004s | **40%** | Acceptable |
58+
| Vararg function | **1.29 M/s** | 3.58 M/s | **36%** | Acceptable |
5859

5960
### Table Operations
6061
| Operation | Lua-RS | Native Lua | % of Native | Status |
6162
|-----------|--------|-----------|-------------|--------|
62-
| Array creation & access | **2.94 M/s** | 11.11 M/s | **26%** | Needs optimization |
63-
| Table insertion | **46.40 M/s** | 66.67 M/s | **70%** | Good |
64-
| Table access | **81.39 M/s** | 166.67 M/s | **49%** | Acceptable |
65-
| Hash table insertion (100k) | **0.023s** | 0.030s | **77%** | Good |
66-
| ipairs iteration (100×1M) | **5.227s** | 2.122s | **41%** | Acceptable |
63+
| Array creation & access | **5.10 M/s** | 11.24 M/s | **45%** | Acceptable |
64+
| Table insertion | **71.99 M/s** | 71.43 M/s | **101%** | Excellent 🏆 |
65+
| Table access | **128.46 M/s** | 166.67 M/s | **77%** | Good |
66+
| Hash table insertion (100k) | **0.022s** | 0.030s | **136%** | Excellent 🏆 |
67+
| ipairs iteration (100×1M) | **6.785s** | 2.098s | **31%** | Needs optimization |
6768

6869
### String Operations
6970
| Operation | Lua-RS | Native Lua | % of Native | Status |
7071
|-----------|--------|-----------|-------------|--------|
71-
| String concatenation | **2775.30 K/s** | 4545.45 K/s | **61%** | Good |
72-
| String length | **168.46 M/s** | �?M/s | N/A | Excellent |
73-
| string.sub | **7768.74 K/s** | 20000.00 K/s | **39%** | Acceptable |
74-
| string.find | **6567.84 K/s** | 20000.00 K/s | **33%** | Needs optimization |
75-
| string.gsub (10k) | **0.101s** | 0.152s | **66% faster** | Excellent 🏆 |
72+
| String concatenation | **2748.53 K/s** | 4545.45 K/s | **60%** | Good |
73+
| String length | **156.99 M/s** | 100.00 M/s | **157%** | Excellent 🏆 |
74+
| string.sub | **8155.08 K/s** | 25000.00 K/s | **33%** | Acceptable |
75+
| string.find | **5553.24 K/s** | 16666.67 K/s | **33%** | Acceptable |
76+
| string.gsub (10k) | **0.104s** | 0.152s | **146%** | Excellent 🏆 |
7677

7778
### Control Flow
7879
| Operation | Lua-RS | Native Lua | % of Native | Status |
7980
|-----------|--------|-----------|-------------|--------|
80-
| If-else | **89.21 M/s** | 119.05 M/s | **75%** | Good |
81-
| While loop | **142.52 M/s** | 136.99 M/s | **104%** | Excellent 🏆 |
82-
| Repeat-until | **113.66 M/s** | 172.41 M/s | **66%** | Good |
83-
| Nested loops (1000×1000) | **232.67 M/s** | 250.00 M/s | **93%** | Excellent 🏆 |
81+
| If-else | **99.71 M/s** | 119.05 M/s | **84%** | Good |
82+
| While loop | **127.10 M/s** | 149.25 M/s | **85%** | Good |
83+
| Repeat-until | **114.36 M/s** | 188.68 M/s | **61%** | Good |
84+
| Nested loops (1000×1000) | **243.30 M/s** | 250.00 M/s | **97%** | Excellent 🏆 |
8485

8586
---
8687

@@ -104,11 +105,18 @@ Performance benchmarks run automatically on push to `main` or `refactor` branche
104105

105106
## Performance History
106107

108+
### November 30, 2025 - call_function_internal Optimization
109+
- Eliminated duplicate dispatch loop in `call_function_internal`
110+
- Now directly calls `luavm_execute` instead of copying 300+ lines of dispatch code
111+
- Reduced code size, improved CPU cache efficiency
112+
- Integer addition now **101% of native** (faster than native Lua!)
113+
- Float multiplication now **99% of native**
114+
- Table insertion now **101% of native** (faster than native Lua!)
115+
107116
### November 29, 2025 - While Loop Optimization
108117
- Optimized while/repeat loop bytecode generation
109-
- While loop now **104% of native** (faster than native Lua!)
110-
- Integer addition improved to **96% of native**
111-
- Nested loops at **93% of native**
118+
- While loop at **85% of native**
119+
- Nested loops at **97% of native**
112120

113121
### November 24, 2025 - CallFrame Optimization
114122
- Implemented code pointer caching in CallFrame
@@ -120,17 +128,19 @@ Performance benchmarks run automatically on push to `main` or `refactor` branche
120128
## Architecture Notes
121129

122130
### Why Some Operations are Faster Than Native
123-
- **While loop**: Optimized bytecode generation produces fewer instructions
131+
- **Integer addition/Table insertion**: Rust's optimizations for integer operations
124132
- **string.gsub**: Rust's string handling is more efficient for pattern matching
133+
- **Hash table insertion**: Optimized Lua-style open addressing hash table
134+
- **String length**: Direct access to pre-computed length field
125135

126136
### Known Performance Bottlenecks
127-
1. **Match dispatch**: Rust match vs C computed goto (~8% overhead)
128-
2. **LuaValue size**: 16 bytes vs NaN-boxing 8 bytes
129-
3. **Function calls**: Frame allocation overhead
137+
1. **ipairs iteration**: Iterator overhead compared to C implementation
138+
2. **Vararg functions**: Extra allocation and copying overhead
139+
3. **Recursive calls**: Frame allocation overhead
130140
4. **Array creation**: GC allocation patterns
131141

132142
---
133143

134144
## Detailed Optimization History
135145

136-
See git history for detailed optimization phases (Phase 1-23).
146+
See git history for detailed optimization phases (Phase 1-24).

‎README.md‎

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -12,21 +12,22 @@ A Lua 5.4 interpreter implemented in Rust, primarily developed through AI-assist
1212

1313
## Test Coverage
1414

15-
Current test status: **252 out of 252 tests passing (100%)** ✅
15+
Current test status: **302 out of 302 tests passing (100%)** ✅
1616

1717
### Performance
1818

1919
[![Benchmarks](https://github.com/CppCXY/lua-rs/actions/workflows/benchmarks.yml/badge.svg)](https://github.com/CppCXY/lua-rs/actions/workflows/benchmarks.yml)
2020

21-
**Overall**: 40-104% of native Lua 5.4.6 performance
21+
**Overall**: 30-100%+ of native Lua 5.4.6 performance
2222

23-
**Highlights** (November 29, 2025):
24-
- 🏆 **While loop**: **104%** of native (faster than native Lua!)
25-
- 🏆 **Integer addition**: **96%** of native
26-
- 🏆 **Nested loops**: **93%** of native
27-
- 🏆 **string.gsub**: **66% faster** than native
28-
- 🎯 Good performance: Float ops (77%), Hash tables (77%), Control flow (66-75%)
29-
- 📊 Acceptable: Function calls (41-43%), Table operations (41-70%)
23+
**Highlights** (November 30, 2025):
24+
- 🏆 **Integer addition**: **101%** of native (faster than native Lua!)
25+
- 🏆 **Float multiplication**: **99%** of native
26+
- 🏆 **Table insertion**: **101%** of native (faster than native Lua!)
27+
- 🏆 **Hash table insertion**: **136%** of native (36% faster!)
28+
- 🏆 **string.gsub**: **146%** of native (46% faster!)
29+
- 🎯 Good performance: Control flow (61-97%), Table access (77%)
30+
- 📊 Acceptable: Function calls (36-59%), String operations (33-60%)
3031

3132
See detailed analysis: [Performance Report](PERFORMANCE_REPORT.md)
3233

@@ -59,7 +60,8 @@ chmod +x run_benchmarks.sh && ./run_benchmarks.sh
5960
- ✅ **UTF-8**: Full UTF-8 support (`codes`, `codepoint`, `len`, `offset`, `char`)
6061
- ✅ **Coroutine**: `create`, `resume`, `yield`, `status`, `close`, `isyieldable`
6162
- ✅ **Package**: `require`, `module`, `searchers` (partial)
62-
- ⚠️ **IO**: Basic file operations (has known memory issues, tests skipped)
63+
- ✅ **IO**: File operations (`open`, `close`, `read`, `write`, `lines`, `seek`, `type`, `tmpfile`, `flush`)
64+
- ✅ **OS**: System functions (`time`, `date`, `clock`, `difftime`, `getenv`, `remove`, `rename`, `execute`, `exit`, `tmpname`)
6365

6466
### Known Limitations ⚠️
6567

@@ -192,14 +194,16 @@ This project demonstrates **successful AI-assisted systems programming**. It was
192194

193195
The codebase was developed through iterative AI assistance with human oversight. Key achievements:
194196
- ✅ Implemented a working Lua 5.4 VM from scratch
195-
- ✅ Achieved 100% test compatibility (252/252 tests)
197+
- ✅ Achieved 100% test compatibility (302/302 tests)
196198
- ✅ Successfully debugged and fixed critical memory safety issues
197199
- ✅ Implemented advanced optimizations (tail calls, hash tables, direct pointers)
198200
- ✅ Reached **production-ready correctness** with **competitive performance in key areas**
199201

200202
### Recent Improvements (November 2025)
201-
- **November 29**: While loop bytecode optimization (now 104% of native!)
202-
- **November 29**: Integer addition optimization (96% of native)
203+
- **November 30**: Optimized `call_function_internal` (eliminated duplicate dispatch loop)
204+
- **November 30**: Added 30 new tests for IO/OS standard libraries (302 total tests)
205+
- **November 30**: Integer addition/Table insertion now **faster than native Lua**
206+
- **November 29**: While loop bytecode optimization
203207
- **November 24**: CallFrame code pointer caching
204208
- **November 24**: C function call optimization (eliminated copying)
205209
- **November 24**: Hash table restructure (Lua-style open addressing)
@@ -225,4 +229,4 @@ MIT License - See [LICENSE](LICENSE) file for details.
225229

226230
---
227231

228-
**Status**: Production-ready correctness (252/252 tests) with competitive performance in hash operations and pattern matching. Suitable for embedded scripting and educational purposes.
232+
**Status**: Production-ready correctness (302/302 tests) with competitive performance. Integer addition and table insertion now **faster than native Lua**. Suitable for embedded scripting and educational purposes.

0 commit comments

Comments
 (0)