C Function calls from JS after faster than JS function calls?

[ammarahm-ed]

I ran this on multiple devices and found C function calls to be faster than JS function calls in quickjs. I want to know if this is really possible? How can a js call be slower than calling a c function from JS.

[saghul]

Can you share an example?

[ammarahm-ed]

The js function and the c function, both return a number, "6". I will share the benchmark code to try.

[ammarahm-ed]

Here's the benchmark code:

const results = [];

function formatNumber(num) {
    return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

const obj = {
    value: 6
}

function bench(n, fn) {
    for (let i = 0; i < n; i++) {
        fn();
    }
    let total = 0;
    let accum = 0;
    const start = performance.now();
    for (let i = 0; i < n; i++) {
        accum += fn();
    }
    const totalTime = (performance.now() - start) * 1e6;
    if (accum != 6 * n) {
        throw new Error(`accum [is incorrect: ${accum}`);
    }
    const avgTime = totalTime / n;
    const ops = 1e11 / avgTime;
    results.push(`${fn.name}:\navg ops: ${formatNumber(Math.round(ops))} ops/sec\navg time: ${avgTime.toFixed(2)} ns/iter`);
}

function jsValueFunc() {
    return 6;
}



bench(1e6, function nativeValue() {
    return nativeValueFunc();
});

bench(1e6, function jsValue() {
    return jsValueFunc();
});

console.log(results.join("\n"));

[ammarahm-ed]

And here's the C function, copied from the node api bindings I am working on but it's a simple C function.

JSValue globalValue = JS_GetGlobalObject(context);
JSValue jsNativeEngine = (JSValue)JS_MKPTR(JS_TAG_INT, (*env));
    
JSValue nativeValueFunc = JS_NewCFunctionData(context,
                                                  [](JSContext* ctx, JSValueConst thisVal, int argc, JSValueConst* argv, int magic,
                                                     JSValue* funcData) -> JSValue {
        return JS_NewInt32(ctx, 6);
    },0, 0, 1, &jsNativeEngine);
    
    
    
    JS_SetPropertyStr(context, globalValue, "nativeValueFunc", nativeValueFunc);

[bnoordhuis]

It's not too surprising because quickjs has to perform a fair amount of bookkeeping on JS function entry (and, to a lesser extent, exit.)

Both the C and JS function don't really do anything except return so that bookkeeping turns into significant overhead for the JS function, whereas the C function is probably literally only two or three assembly instructions. If anything, I'm surprised the gap isn't bigger!

[ammarahm-ed]

I see. Thanks for explaining. It does make sense now.