V8 Presentation NodeConf

Transcript

1. Architectural Changes In V8 And Their Impact On Performance Tamar Twena-Stern
2. Tamar Twena-Stern twitter @SternTwena linkedin /tamarstern tamar.twena@gmail.com
3. V8 - Introduction
4. A Crucial Component In Node.js Architecture
5. V8 In Node.js Has Two Roles Code Parsing And Execution Memory Management
6. Since JavaScript And Node.js Are Very Popular , V8 Have A Hard Task
7. To Be A Super Fast Interpreter For A Dynamic Type Language
8. Compiler - Translates High level code to machine code in compilation process Interpreter - directly executes source code written in a high-level programming, translate to machine code line by line Dynamic Typed Languages - checks variable types at runtime Static Typed Languages - checks variable types at compile time
9. Compilers Interpreters Execution Overhead Efficient Memory Usage Platform Specific Optimizations Why Compilers Perform Better than interpreters
10. Dynamic Type Languages Have Perform Those Techniques At Runtime • Runtime Type Checking • Dynamic Dispatch
11. Compiler, static typed language == Interpreter, dynamic type language == == Interpreter, dynamic type language So In Most Cases
12. To Make V8 Super Fast, 2 Compilers And One Interpreters To The Rescue
13. • Ignition Interpreter • Turbofan Compiler • Sparkplug Compiler
14. Code Parsing Pipeline - Evolution
15. Parser And AST
16. function add(a,b) { return a+b; } Simple AST Example
17. Ignition Interpreter
18. Turbofan Compiler - JIT Compiler
19. Help turbofan work fast - Use fewer function input type variations
20. monomorphic(myNumber : number) : void;
21. polymorphic(myNumber : number) : void; polymorphic(myString: String) : void;
22. megamorohic(myNumber : number) : void; megamorohic(myString: String) : void; megamorohic(myPerson : Person) : void; megamorohic(myFirstAray: Array<String>) : void; megamorohic(mySecondArray: Array<number>) : void;
23. Optimization And De-Optimization
24. De-Optimization - Example class Person { constructor(name, age) { this.name = name; this.age = age; } } function getAge(person) { return person.age; }
25. De-Optimization - Example for (let i = 0 ; i < 1000000 ; i++ ) { // After X iterations the Turbofan binary will be created const p = new Person("Tamar", 30); getAge(p); }
26. De-Optimization - Example const differentPerson = new Person("Tamar", 30);; // Adding dynamic property, hidden class changed differentPerson.salary = 3000; //binary released getAge(differentPerson);
27. Deoptimization Benchmark
28. Optimized Code function concat_str(arg) { return arg + arg; } // Start for (let i = 0 ; i< 100000; i++) { concat_str("a"); } // End
29. Code With DeOptimization function concat_str(arg) { return arg + arg; } // Start for (let i = 0 ; i< 100000; i++) { if (i == 10231) { concat_str(1); } else { concat_str("a"); } } // End
30. Comparing Runs - 100,000 and 1,000,000 loop
31. Union Types function add(value: string | number) { // Function logic }
32. Finding performance killers with --trace-opt --trace-deopt
33. De-optimizing After Transfering Different Type [marking 0x070b4aa60601 <JSFunction (sfi = 0x3dc4dce32af9)> for optimization to TURBOFAN, ConcurrencyMode::kConcurrent, reason: hot and stable] [compiling method 0x070b4aa60601 <JSFunction (sfi = 0x3dc4dce32af9)> (target TURBOFAN) using Turbofan OSR] [optimizing 0x070b4aa60601 <JSFunction (sfi = 0x3dc4dce32af9)> (target TURBOFAN) - took 0.000, 0.625, 0.000 ms] [bailout (kind: deopt-eager, reason: Insufficient type feedback for call): begin. deoptimizing 0x070b4aa60601 <JSFunction (sfi = 0x3dc4dce32af9)>, opt id 0, bytecode offset 30, deopt exit 4, FP to SP delta 96, caller SP 0x00016bc4a310, pc 0x000128853144]
34. Let’s Go Back To V8 Code Parsing Pipeline
35. • Application start • Command line application • Dynamic environment with de-optimizations Week Scenarios
36. This Pipeline Works Well When Your Application Is Already “Warm”, But What if it is not the case yet ?
37. So This Pipeline Turned Into …
38. V8 New Architecture - Mid Tier Compiler
39. const a = 1; const b = doStuff1(a); const c = doStuff2(a); for (let i=0; i<100000; i++) { doStuff1(a);//After X runs,run Machine Code (TurboFan) } Before Adding SparkPlug
40. const a = 1; const b = doStuff1(a); // run Machine Code (SparkPlug) const c = doStuff2(a); // run Machine Code (SparkPlug) for (let i=0; i<100000; i++) { doStuff1(a); // After X runs, run Machine Code (TurboFan) } After Adding SparkPlug
41. Ignition Does The Hard Work • variable resolution • parentheses or arrow functions • desugaring destructuring statements
42. SparkPlug Real World Performance Improvement
43. Improve Class Initializations
44. So , How JavaScript Objects Are Built Behind The Scenes ?
45. JavaScript Objects
46. Shapes To Represent Object Types
47. The Offset Lookup Was Very Expensive
48. The Solution - The Inline Cache
49. Monomorphic, Polymorphic, Megamorphic - The performance effect of the inline cache
50. getX({ x: 3 }) // Cache size = 1 getX({ x: 3, a: 1 }) // polymorphic getX({ x: 3, b: 1 }) // polymorphic getX({ x: 3, c: 1 }) // polymorphic, several cache entries getX({ x: 3, d: 1 }) // megamorphic - Entries are overwritten on collisions
51. Until recent V8 versions - Inline Cache was not implemented for class fields and private methods
52. const person = {}; person.age = 42; function getAge(p) { return p.age; } class Person { age; constructor(age) { this.age = age; } getAge() { return this.age; } }
53. Benchmark - Class Initialization In Previous And Latest Node.js Versions
54. Benchmark Setup class Person { age; constructor(age) { this.age = age; } function getAge(p) { return p.age; } }
55. Benchmark // Start for (let i = 0 ; i < 1000000 ; i++ ) { const p = new Person(30); p.getAge(p); } // End
56. Class Field Initialization Improvement
57. Summary
58. Make Sure Your Types Don’t Change function add(value: string | number) { // Function logic }
59. Changing Your Request Schema
60. Tamar Twena-Stern twitter @SternTwena linkedin /tamarstern tamar.twena@gmail.com