8 ms·
Surprises in GopherJS Performance
- Touche 11y agoThese are the types of articles that keep me coming back to HN. Spectacular analysis.
- pauljz 11y agoIn the final example where he switches to int32 for Go (after "Let's make it use int32 consistently and try again"), he runs gopherjs twice instead of running go and gopherjs. I hope that's a typo. The reasoning seems correct, but it'd be nice to have the benchmarks corrected to verify.
- shurcooL 11y agoIt is indeed a typo, sorry about that! 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/acea7a862c161796697aed812d9142945d09d1e8#commitcomment-13497916 https://github.com/gopherjs/gopherjs.github.io/commit/acea7a... [2] https://gist.github.com/shurcooL/02183a57c51b28eaadf4 https://gist.github.com/shurcooL/02183a57c51b28eaadf4
- kenOfYugen 11y agoJS win and Go win. GopherJS was the reason I was considering making the transition to full-stack Go.
- gizmo 11y agoThese micro programs are very easy to JIT, so nearly identical performance is to be expected. It's when you get larger programs that C compilers with function inlining and better cache locality and whole program optimization leave JIT compiled languages in the dust. 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.
- hacker_9 11y agoAre you sure? According to [1] the V8 Javascript engine also includes function inlining. Additionally cache locality is still achievable in JS, if the user designs their data structures/code-patterns with the goal of maximising locality [2]. 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] http://www.html5rocks.com/en/tutorials/speed/v8/ http://www.html5rocks.com/en/tutorials/speed/v8/ [2] http://jsperf.com/cache-lines-a-demonstration http://jsperf.com/cache-lines-a-demonstration
- azakai 11y agoYes, v8 and all other modern JS engines perform function inlining and type profiling. Still, it is extremely common to see modern JS engines be competitive with C on small microbenchmarks, but lag behind on large, realistic codebases. There are several reasons for this: 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.
- hinkley 11y agoWhen the users complain that the app is 'too slow' and the devs say "we've done everything we can", I'm usually the guy who goes and finds another 30% without doing anything crazy. 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)
- jzelinskie 11y agoWhat's the JS interop story with GopherJS? Is it possible to import native JS libraries and use them?
- nulltype 11y agoGopherJS compiles to "readable" JavaScript, so yes. You have to do something like js.Global.Call("functionname", arg1)
- fizzbatter 11y agoSort of readable, imo. I mean, a few simple function calls are nicely readable, but blocking calls quickly turn into an unreadable mess in my experience.
- runnr_az 11y agoI always expect these stories to be about a JS client for Gopher... and I guess I'm always a bit disappointed.
- mseepgood 11y agoWhat excites you so much about the Gopher protocol? It's very boring (less interesting than e.g. FTP) and scarcely in use. If you're looking for a JS client for the Gopher protocol use OverbiteFF or something.
- mtdewcmu 11y ago>> low-level C implementation compiled with -O3, the max optimization setting. IME, -O2 always comes out faster than -O3. In this case, though, the difference is fairly insignificant.
- KMag 11y agoNote that -Os and -Oz often give you faster code than -O2. Also -O3 doesn't turn on all optimizations. (Most notably, -O3 won't omit the frame pointer for leaf calls. Yes, omitting the frame pointer can make debugging harder.)
- dpayne 11y agoGreat article on the complexities of investigating performance issues! Another very interesting surprise is when I run this locally on my macbook, clang is much faster 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
- hinkley 11y agoThe speed of the answer doesn't matter so much when the answer is wrong. And (after checking Google) BOTH of those are wrong. :/
- dpayne 11y agoRecompiling without fastmath gives the same answer as the article "3.1415926545880506". mac >> clang++ -O3 -march=native main.cpp mac >> ./a.out 3.1415926545880506 total time taken is: 4.3861569999999999s Twice as slow as the fastmath version but still faster than the go version.
- e12e 11y agoClearly the two results are different, so something strange is going on. But you need to define wrong, consider incrementally approximating pi in 7 steps: 100,50,25,12,4,2,3,3.5 > 3.5 Or even: 100,90,80,70,60,50,40 > 40 I'm assuming you mean wrong as in the algorithm implemented with arbitrary precision would en up with a different set of digits for the number of iterations given? Or something along those lines?
- hinkley 11y agoOh, I mean they're both wrong in the 10th position even though they agree. But it is curious that they diverge after that. It's probably more a problem of the algorithm not calculating significant figures and truncating the answer.
- 11y ago
- jtblin 11y agoWhat I find the most surprising here is how optimised the v8 engine is. Javascript code running on v8 is as performant as native go code or as optimised C code. Obviously it's just a use case but still, mind blowing.
- fizzbatter 11y agoI want to see examples like this for Go Channels. Benchmarks, analysis, etc. GopherJS is really cool, i just want to see the real world Go questions asked and answered.