idea: opcode dispatch performance improvements

[zhuzhu81998]

Just started looking into boa's VM. It appears that boa uses call threading for opcode dispatch via function pointers:

boa/core/engine/src/vm/mod.rs

Lines 876 to 891 in 75c0a75

	while let Some(byte) = self
	.vm
	.frame
	.code_block
	.bytecode
	.bytecode
	.get(self.vm.frame.pc as usize)
	{
	let opcode = Opcode::decode(*byte);
	match self.execute_one(Self::execute_bytecode_instruction, opcode) {
	ControlFlow::Continue(()) => {}
	ControlFlow::Break(value) => return value,
	}
	}

There should be room for measurable improvements according to https://github.com/tipo159/rust-instruction-dispatch .
Running the experiments with rustc 1.93.0 on my machine (Lunar Lake, Q3 2024):

Approach	Average of 100 results (ns)
direct-call-threading	2_947_553
switch-dispatch	2_469_013
direct-tail-call-threading	1_594_078

While tipo159/rust-instruction-dispatch does have some implementation inconsistencies (which perhaps caused switch-dispatch to be better than direct-call-threading), it would appear that direct-tail-call-threading is more superior and does not require writing ASM by hand either.

[zhuzhu81998]

Some more reports on the tail call approach:
CPython: https://lwn.net/Articles/1010905/ (PR: python/cpython#128563)
QuickJS: bellard/quickjs#466
Random Reddit comment: https://www.reddit.com/r/rust/comments/1nt8enz/preserve_nonelike_calling_convention/

Rust stable compiler unfortunately does not support guranteed tail call right now. nightly does have it (rust-lang/rust#144232) so maybe some experimental work and/or refactoring as preparations might be nice.

[hansl]

There are some very interesting points in here. That sounds like a good starting point for exploration.

[zhuzhu81998]

I will look more into it then : )

[shreyadesai20042009]

Hi, I’m interested in exploring the direct tail-call dispatch approach.

Before starting implementation, would you prefer:

• An experimental branch for benchmarking?
• A feature-gated prototype?
• Or performance measurement improvements first?

I’d be happy to start with a small benchmarking comparison inside the repo.

[jedel1043]

@zhuzhu81998 is already working on this.

[zhuzhu81998]

So switch for boa is definitely slower. Perhaps the toy benchmark showed switch to be faster is partially due to how little instructions there are (like 4).

To test out tail call i need to do a bit more playing around (currently it just goes stack overflow, because apparently you can not let rust handle the destructor calls if you want tail call + other caveats i need to sort out)