QueensJS March 4, 2015

Optimizing, testing, and profiling JavaScript, especially within Node, with a focus on how V8 works.

Github: https://github.com/sandro-pasquali/v8-optimization-talk

Transcript

1. spasquali@gmail.com HIR, Betaworks
2. V8 is Good For You Optimizing, Testing, and Profiling your Node Code
3. Will be talking about: - Coding patterns to avoid (sub-optimal codes) - Tools to help you test whether your code is optimal - Tools for profiling running code
4. V8 is not an interpreter JS code is always running compiled. A first-pass (generic) compiler makes a quick pass first; next an optimizing compiler works against running code.
5. Compilers like to predict the future
6. JavaScript is unpredictable
7. Prototypes JavaScript is a prototype-based language. Objects are created by cloning other objects.
8. Dynamic Typing Types are not explicit, and properties on objects can be changed at any time.
9. This is Hard Dynamic typing and prototypes (among other things) make it difficult for a compiler to anticipate the future.
10. Compilation Step 1 First-pass at compilation, where type analysis and other detailed analysis is deferred, achieving fast compilation, allowing JavaScript to “start running” almost instantly.
11. Compilation Step 2 An optimizing compiler watches running code and attempts to determine future runtime characteristics. For example, if a function is executing several thousand times with the same arguments, it is optimized.
12. Optimism is a V8 thing Optimistic, because nothing in JavaScript prevents a different call signature, variable type, object definition, from appearing in the future. The compiler tries to find hot functions it can make assumptions about.
13. Good guys (sometimes) finish last Assumptions help us make decisions quickly, but what if we’re wrong? If V8 turns out to be wrong about the future, it must de-optimize a previously optimized function. Too many deoptimizations on a function? V8 stops trying — deoptimization hell
14. This is the main point Predictable JavaScript can be optimized. Unpredictable JavaScript cannot be optimized.
15. V8 Solves all my Problems! Compiling removes interpreter overhead. It can’t optimize code that…cannot be optimized (ie. whose behavior is unpredictable).
16. Optimizing
17. Optimizing Objects V8 adds hidden classes to track properties in objects. - Try to not add properties after object creation - Try not to delete properties - Try to add properties in the same order. This allows V8 to share maps
18. This: function Foo() { this.a = 1; this.b = 2; this.c = 3; }
19. Not this: function Foo() { this.a = 1; this.b = 2; } var bar = new Foo(); bar.c = 3;
20. Advice If you use an object as if it is a hash table, v8 will turn it into a hash table. You don’t want that.
21. Consistent Numbers Not good: [1, 3.4, 6, 23, 9.75] good: [1, 3, 6, 23, 9] ** Try not to mix integers and floats in arrays, and in assignments, and anywhere else.
22. No sparse arrays Forces V8 to use a sub-optimal hash-table lookup, rather than linear storage (offsets)
23. More about Arrays - Don’t remove elements - Start at zero(0) - Be consistent in array member types
24. Avoid polymorphic functions If the arity and/or type of arguments in a function signature vary, that function will suffer deoptimization
25. Generally Functions containing eval(), with{} or DEBUGGER are never optimized.
26. More Several people have written in detail about optimization techniques. Google it.
27. Tracing Optimizations There are tools available to test the optimizability of your code.
28. New Runtime Functions --allow-natives-syntax var someFunc = function foo(){} console.log(%FunctionGetName(someFunc)); // foo
29. Inspect V8 compilation function square(operand) { return operand * operand; } // Make first pass to gather type information square(3); // Ask that the next call of #square trigger an optimization attempt; %OptimizeFunctionOnNextCall(square); // Call again... square(3);
30. node --allow-natives-syntax --trace_opt --trace_deopt testing/optimized.js ** Let’s see what happens when we run this
31. Remember Objects? Let’s see what happens when we delete properties node --allow-natives-syntax testing/objects.js
32. It’s a long list of functions… https://gist.github.com/totherik/3a4432f26eea1224ceeb This package tries to cut the verbosity down: https://www.npmjs.com/package/v8-natives
33. Profiling Getting a snapshot of application performance
34. To start… npm install -g node-tick-processor This will become useful later…
35. What’s happening We’re going to log what v8 is doing while it runs a program. Then we’re going to inspect the results.
36. To profile: node --prof profiling/logreader.js
37. You can now inspect this profile By hand (not so clear) By using node-tick-processor (clearer) ~ = not optimized * = optimized
38. But wait, there’s more! chrome://tracing/
39. More info Thorsten Lorenz is doing lot of work (and writing) on v8 performance and profiling. https://thlorenz.github.io/v8-perf/ https://github.com/thlorenz/v8-perf/issues/4
40. Thanks!