Goja can be faster than v8 for quick actions

[danthegoodman1]

Just wanted to share some notes: When it comes to booting an isolate in goja vs rust v8 (release build), I've found goja to be a lot faster.

With rust, isolates would boot in 1.5-2.2ms with the same code.

With goja, I was getting anywhere from 300us-700us. A bit more relative range, but execution happened faster.

function multiply(a, b) {
                return a * b;
            }

Multiplying 3*4 (rust has a pretty bad cold first boot of the binary):

 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 4523us
 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 1727us
 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 1920us
 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 1931us
 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 2051us
 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 1653us
 dangoodman: ~/code/learningRust/rust_v8 git:(main) ✗ ./target/release/rust_v8                                                                           3:15PM
3 * 4 = 12 in 1669us

 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:16PM
Goja multiply in 576.833µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 645.875µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 598.583µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 562.833µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 650.417µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 648.167µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 626.25µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 647.25µs result: 12
 dangoodman: ~/code/test-go-js git:(main) ✗ go run .                                                                                                     3:17PM
Goja multiply in 634.667µs result: 12

package main

import (
	"fmt"
	"github.com/dop251/goja"
	"time"
)

const MultiplyInJS = `function multiply(a, b) {
	return a*b
}`

func gojaMultiplyJS() {
	start := time.Now()
	vm := goja.New()
	_, err := vm.RunString(MultiplyInJS)
	if err != nil {
		panic(err)
	}
	multiply, ok := goja.AssertFunction(vm.Get("multiply"))
	if !ok {
		panic("Not a function")
	}

	res, err := multiply(goja.Undefined(), vm.ToValue(3), vm.ToValue(4))
	if err != nil {
		panic(err)
	}

	fmt.Println("Goja multiply in", time.Now().Sub(start), "result:", res.ToInteger())
}

use std::time::SystemTime;

fn main() {
    // Initialize V8.
    let platform = v8::new_default_platform(0, false).make_shared();
    v8::V8::initialize_platform(platform);
    v8::V8::initialize();

    {
        let start = SystemTime::now();
        // Create a new Isolate and make it the current one.
        let isolate = &mut v8::Isolate::new(v8::CreateParams::default());

        // Create a stack-allocated handle scope.
        let handle_scope = &mut v8::HandleScope::new(isolate);

        // Create a new context.
        let context = v8::Context::new(handle_scope);

        // Enter the context for compiling and running the hello world script.
        let scope = &mut v8::ContextScope::new(handle_scope, context);

        // Create a string containing the JavaScript source code for the 'multiply' function.
        let c_source = r#"
            function multiply(a, b) {
                return a * b;
            }
        "#;

        let source = v8::String::new(scope, c_source).unwrap();

        // Compile the source code.
        let script = v8::Script::compile(scope, source, None).unwrap();

        // Run the script to define the function.
        script.run(scope).unwrap();

        // Get the multiply function from the global object.
        let global = context.global(scope);
        let key = v8::String::new(scope, "multiply").unwrap();
        let multiply_value = global.get(scope, key.into()).unwrap();

        // Ensure it's a function.
        if !multiply_value.is_function() {
            panic!("multiply is not a function");
        }

        let multiply_fn = v8::Local::<v8::Function>::try_from(multiply_value).unwrap();

        // Now we can call the `multiply` function from Rust.
        let arg1 = v8::Number::new(scope, 3.0);
        let arg2 = v8::Number::new(scope, 4.0);
        let args = &[arg1.into(), arg2.into()];
        let result = multiply_fn.call(scope, global.into(), args).unwrap();

        // Convert the result to a number.
        let result = result.to_number(scope).unwrap();
        println!("3 * 4 = {} in {}us", result.value(), start.elapsed().unwrap().as_micros());
    }
}