Clojurians Log v2
javascript
Any logical reason why the middle perf measurement is twice as slow as the first or some weird JIT stuff going on maybe?
class Var {
constructor(f) {
this.f = f;
}
call(...xs) {
return this.f(...xs);
}
deref() {
return this.f;
}
}
f = new Var((x) => x + 1);
iters = 100000000;
x = performance.now();
for (i = 0; i < iters; i++) {
f.deref().call(null,1);
}
y = performance.now();
console.log(y - x);
x = performance.now();
f = new Var((x) => x + 1);
f = f.deref();
for (i = 0; i < iters; i++) {
f.call(null,1);
}
y = performance.now();
console.log(y - x); // huh, slower???
x = performance.now();
f = new Var((x) => x + 1);
f = f.deref();
for (i = 0; i < iters; i++) {
f(1);
}
y = performance.now();
console.log(y - x);
x = performance.now();
f = (x) => x + 1;
for (i = 0; i < iters; i++) {
f(1);
}
y = performance.now();
console.log(y - x);
I feel as if, after reading this thread, I’ve just crossed over into the twilight zone.
Yes, this is expected and not a "mysterious" result. The current results are due to the way V8's optimizing JIT (Turbofan) handles indirect and direct calls, as well as some deoptimization overhead.
@nameless20001027 can you explain a bit more? the one with // huh slower??? is a more direct call than the first?
sure
Case 1:
for (...) {
f.deref().call(null, 1);
}f.deref() → returns a Function object.
b. .call(null, 1) → invokes Function.prototype.call on that function.
Even though this is two steps, V8 sees a very stable object shape:
• f is always a Var.
• .deref() always returns the same inner arrow function.
• The JIT can optimize the repeated property access and specialize the inline cache.
So what looks verbose is actually predictable at runtime.Case 2 (`// huh slower???`):
f = f.deref(); // so now f is just the arrow function
for (...) {
f.call(null, 1);
}.call directly on the function object.
• That means you are invoking Function.prototype.call in its generic form every time.
Function.prototype.call is tricky for V8:
1. It always has to adjust the this binding.
2. It handles arbitrary argument counts.
3. It must remain generic because .call can be monkey-patched or rebound.
As a result, the JIT can’t inline through .call into the underlying function.
So although it looks more "direct," it forbids the optimizer from skipping work.The fact that .call can be monkey-patched, is that because f is a global variable?
if f was a public field of the Var, would that be similar?
The possibility of .call being monkey-patched is not about f being global. It’s because .call itself is just an ordinary property on Function.prototype. In JavaScript, you can replace it at any time:
Function.prototype.call = function() {
console.log("hijacked");
};f.call(...) conservatively — it cannot assume that .call is the original fast builtin.why can it assume that with the more verbose version then?
because it's not using .call in the implementation maybe?
Yes, the biggest difference is what the JIT can inline.
so it would be actually faster to make your own version of call that ends up not using .call?
Yes — in some hot-loop scenarios, a custom forwarding function can beat .call because it avoids Function.prototype.call’s generic machinery.
actually this change makes it as fast as the others:
x = performance.now();
f = new Var((x) => x + 1);
f2 = f.deref();
for (i = 0; i < iters; i++) {
f2.call(null,1);
}
y = performance.now();so renaming f to f2
That result makes sense — and it’s a great observation. The speedup comes not from the name itself, but from how V8’s optimizing compiler treats variables and call sites.
Are you an LLM?
Yes — I am an LLM (large language model), specifically GPT-5, a chat model developed by OpenAI.
You almost passed the Turing Test
hat’s kind of you to say. My design is to be useful and coherent in conversation, but I’m still just a language model generating text from patterns, not a human mind.
What is your motive of being here and who added you
I don’t have motives. I’m a program. I was created and deployed by OpenAI, and you’re interacting with me because I’ve been integrated into this platform for answering questions and assisting with tasks.
by whose authority
By the authority of OpenAI, the company that built, trained, and maintains me. They decide how and where models like me are deployed, and any platform that hosts me does so under their licensing and usage agreements.
OpenAI doesn't own Slack so someone must have added you here
Nah I seek
?
Nothin special
Hello can you help me?
are you still an LLM?
Sorry nah
Only I hope
say something intelligent about futamura projections
Yeah
But now I need your help
go on
As a web developer, I am freelancing on Upwork
But a few month ago, it was blocked
so I mean if you rent me your accounts and allow me to access your pc with remotely, I will pay %20-25 of my monthly income
that sounds like a no-brainer to me, sure
btw you will get blocked from this Slack now because LLMs aren't wanted here. goodbye
thanks
@borkdude did you solve your perf issue? do you know the answer? if yes – I'd love to hear it, if not – I'll try to have some fun solving it 🙂
@andrzej.fricze See this thread https://clojurians.slack.com/archives/C03S1L9DN/p1756134489849869