Optimization fast local variables

[HalidOdat]

Depends on #3185

This PR is a WIP, it implements an optimization on function local variables, functions that do not call eval directly or variables that are not escaped, we can keep then on the stack after frame pointer and use and offset to index them (index = fp + offset). This allows us to eliminate the creation of some of the gc collected environments. Which gives us huge performance improvements!

Benchmarks

Main

Uncaught Error: Benchmark had 1 errors
PROGRESS Richards
RESULT Richards 36.0
PROGRESS DeltaBlue
RESULT DeltaBlue 42.2
PROGRESS Encrypt
PROGRESS Decrypt
RESULT Crypto 63.2
PROGRESS RayTrace
RESULT RayTrace 147
PROGRESS Earley
PROGRESS Boyer
RESULT EarleyBoyer 136
ERROR RegExp TypeError: not a constructor
undefined
PROGRESS RegExp
PROGRESS Splay
RESULT Splay 118
PROGRESS NavierStokes
RESULT NavierStokes 136
SCORE 84.6
Uncaught Error: Benchmark had 1 errors

PR

PROGRESS Richards
RESULT Richards 42.3
PROGRESS DeltaBlue
RESULT DeltaBlue 46.5
PROGRESS Encrypt
PROGRESS Decrypt
RESULT Crypto 102
PROGRESS RayTrace
RESULT RayTrace 164
PROGRESS Earley
PROGRESS Boyer
RESULT EarleyBoyer 158
ERROR RegExp TypeError: not a constructor
undefined
PROGRESS RegExp
PROGRESS Splay
RESULT Splay 124
PROGRESS NavierStokes
RESULT NavierStokes 246
SCORE 107

Almost 2x improvment on NavierStokes :)

[github-actions]

Test262 conformance changes

Test result	main count	PR count	difference
Total	95,574	95,574	0
Passed	75,273	75,273	0
Ignored	19,482	19,482	0
Failed	819	819	0
Panics	0	0	0
Conformance	78.76%	78.76%	0.00%

[codecov]

Codecov Report

Attention: Patch coverage is 66.73152% with 171 lines in your changes missing coverage. Please review.

Project coverage is 49.60%. Comparing base (a51581b) to head (d53a0c4).
Report is 514 commits behind head on main.

Files with missing lines	Patch %	Lines
boa_engine/src/bytecompiler/declarations.rs	36.20%	37 Missing ⚠️
boa_engine/src/vm/opcode/get/name.rs	36.58%	26 Missing ⚠️
boa_engine/src/bytecompiler/mod.rs	81.03%	22 Missing ⚠️
boa_engine/src/vm/opcode/delete/mod.rs	11.11%	16 Missing ⚠️
boa_engine/src/vm/opcode/set/name.rs	44.44%	15 Missing ⚠️
boa_engine/src/vm/opcode/control_flow/return.rs	57.14%	12 Missing ⚠️
boa_ast/src/operations.rs	68.96%	9 Missing ⚠️
boa_engine/src/vm/code_block.rs	40.00%	9 Missing ⚠️
boa_engine/src/module/source.rs	0.00%	6 Missing ⚠️
boa_engine/src/bytecompiler/expression/mod.rs	0.00%	5 Missing ⚠️
... and 5 more

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #3194      +/-   ##
==========================================
+ Coverage   49.53%   49.60%   +0.06%     
==========================================
  Files         446      446              
  Lines       43722    44070     +348     
==========================================
+ Hits        21659    21861     +202     
- Misses      22063    22209     +146     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[jedel1043]

Blocked on #3490

[raskad]

@HalidOdat I would like to take a look at continuing development on local variables. We talked about having environment aware bytecode generation for this with analyzed variable scopes. Do you have any more work or ideas on this or should I just start from the current state of this PR? Also, should I keep anything in mind regarding #3798?

[HalidOdat]

Do you have any more work or ideas on this or should I just start from the current state of this PR?

The issue I have with the current implementation is that it does not account for many cases (and it's very hacked together).

My idea for a more proper solution would be to move the compile time environment logic to the parser and have the AST nodes like *Function*, Block contain a compile time environment, LibJS does this. It removes the need for a second pass after parsing (though makes parsing slower if we want to fail fast, but most scripts are valid so I don't think this is an issue).

The second idea was to perform a second pass after the AST generation this would generate a data structure that contains all the scope data that is passed to the compiler, and add a ID to the AST nodes that is None initially and filled in with the scope it points to, making mapping back to the scopes more efficient. This is a simpler approach and I was experimenting with it.

I began working on this but didn't make much progress, you can find the code on my fork (hope it helps): https://github.com/HalidOdat/boa/tree/scope-analysis

Also, should I keep anything in mind regarding #3798?

Hmmm.. The logic on how to allocate register/local variables in the compiler will be shared, besides that I think both tasks can be worked on simultaneously.

I'll create a PR and extract that logic so we can merge it into main.

[raskad]

Quick update on this. I have a working version with scope analysis at parse time. All tests pass and local variables work. I'm now in the process of cleaning up the implementation and removing some hacks.
The benchmark score increases are similar to the ones in the PR here. Overall score + ~23% for my first benchmarks.

I ran into the issue, of needing to track uninitialized variables, since we cannot track if a variable in initialized just with the stack value. Right now I'm just using a call frame local map to track this, but I think I can reduce that to an array to get some better performance.

[jedel1043]

@raskad Tracking uninit variables may be something that is solved by #3037 IIRC

[raskad]

Superseded by #3988