Surprises in GopherJS Performance
gopherjs.org
gopherjs.org
When you have a loop of a billion iterations the JIT compiler can instantly tell that it's worth optimizing whatever is in the loop body. When you have a more complex program the JIT does not know which parts to optimize. Any time spent on this kind of "what should I optimize" meta-analysis has to be earned back by making future code run faster, so you run into diminishing returns pretty quickly.
As the engine does not know the types of variables, or the layout of types immediately there is definitely a slower startup than pure C code, but it looks like the V8 engine does do a lot under the hood to get definite type information and thus get the speed advantages.
1. JS engines must make tradeoffs between what to inline and what not - each inlining requires a recompilation. Offline C compilers don't have such concerns.
2. Inlining creates large functions, and large codebases tend to have large functions anyhow, and large functions take longer to JIT, making realistic codebases much more challenging for JS engines.
3. It's fairly easy for modern JS engines to figure out types at runtime in a small loop. However, when figuring out types in a large program spread over many functions, it takes substantial overhead to try to do a holistic solution, and instead, JS engines generally just do a local analysis and hope that what really needs to be optimized is inlined anyhow - but see 1 and 2. And when not inlining, function call arguments generally do not happen in an optimized type, but in boxed form.
Overall, it is not surprising at all that the article saw C-like performance on a small micro-benchmark, on a modern browser. But in a realistic codebase, there almost certainly would be a large slowdown. That's why asm.js exists and why WebAssembly is on the way.
Two things I see pretty consistently. First is that when there are no tall tent poles (20 functions take 5% of the time each), people don't know what to do, so they don't do anything. Second, and possibly easier to fix, is that people believe the perf analysis tool (the breakdown of where time is spent) is telling them the objective truth. Often it's wrong, which is why we try things, benchmark them, and revert changes if things get worse.
When there are no tall tent poles I switch to invocation count, which is the best secondary indicator of hotspots. There was one method that the perf tool told me was taking 10% of the run time. But the call count was fishy. Due to a bad call structure it was being called far more often than necessary. In the worst spot in the code two sequential calls were calling this function, so I flipped the code around so they could take the answer as an argument (memoization).
I reran the benchmarks. I had removed 50% of calls to a function that took 10% of our time, and the code overall was now 20% (twenty percent!) faster. Why?
Functions allocate memory. They evict cache lines in the data and instruction caches. They might even access constrained resources, like disk. And as you said, they change how the JIT decides to optimize things.
Sometimes, the symptom is that the code that runs immediately afterward gets blamed for problems they didn't create, and the profiler has no way of following the problem back to the root cause, so it assigns blame at the point of contention, not at the start of the contention.
The only tools I've found that helps with this are clean coding practices, and figuring out if your invocation counts match your expectations (I will run a call tree 100 times and then compare the call counts of everything to find things that were called 2+ times as often as they strictly should have been called)
This reminds me on another comment I read on HN, that I consider something of a "performance paradox": https://news.ycombinator.com/item?id=9895531
But the thread you reference is a whole other kettle of fish, and I would call that observation #3 about failing at math.
Your boss says the app needs to run 3x as fast. Not "try to make it 3x faster" but "the customer isn't going to buy unless it's 3x faster because competitors". With targets like that anything taking more than 3% of run time is a target for improvement, because they are taking 10% of the goal run time.
People will adamantly refuse to look at the 4th slowest function until they've done something brilliant with the others, even if it's the easiest to fix. That function is only taking 10% of the time, they'll say, so it's not important. But it's taking 30% of the goal run time, and that's huge.
Oh, yes! It's so useful to keep an eye on invocation counts. For example, one "problematic" service in a team I managed was being analyzed by an engineer on my team. He was focused on % time culprits, but I spied a highly suspicious entry a fair ways down the list taking many, many orders of magnitude more invocations than anything else. Off I went to have a look...
It turns out the original dev had meant to put a blocking call in in the code, but had gotten mixed up and used a polling version instead. (Both were non-obviously named and signature interchangeable. Sigh.) The baseline CPU hit in the perf run wasn't significant, but in context of this service, it produced a very severe performance cliff characteristic under high site load.
A one-line change corrected that error, and suddenly the operations team stopped talking about that service (with evil glares ;-) at every opportunity.
The reasoning seems correct, but it'd be nice to have the benchmarks corrected to verify.
I've fixed it [1] after confirming [2] (yet again just now; I've ran those numbers many many times so I'm very confident it's not a one time fluke).
Thanks for catching it. You're also welcome to try to confirm the results yourself, they should be reproducible!
[1] https://github.com/gopherjs/gopherjs.github.io/commit/acea7a...
mac >> go run main.go
approximating pi with 1000000000 iterations.
3.1415926545880506
total time taken is: 9.706911232s
mac >> clang++ -O3 -ffast-math -march=native main.cpp
mac >> ./a.out
3.1415926545864963
total time taken is: 2.14196s mac >> clang++ -O3 -march=native main.cpp
mac >> ./a.out
3.1415926545880506
total time taken is: 4.3861569999999999s
100,50,25,12,4,2,3,3.5
> 3.5
100,90,80,70,60,50,40
> 40
It's probably more a problem of the algorithm not calculating significant figures and truncating the answer.
So is it possible that the algorithm doesn't converge to correct digits for so "few" iterations?
This particular series, which comes from a series for the arctan of 1, has very slow convergence. An easily better one is Machin's formula, which converges faster than a geometric series (that is, the number of terms needed is at most linear in the number of wanted digits).
IME, -O2 always comes out faster than -O3. In this case, though, the difference is fairly insignificant.
GopherJS is really cool, i just want to see the real world Go questions asked and answered.