Architectural Changes In V8 And How They Will Improve Server Performance

Transcript

1. Architectural Changes In V8 And How They Improve Your Node.js Performance Tamar Twena-Stern
2. Tamar Twena-Stern twitter @SternTwena linkedin /tamarstern tamar.twena@gmail.com
3. What Is V8 ?
4. Few V8 Facts
5. A Crucial Component In Node.js Architecture
6. V8 In Node.js Has Two Roles Code Parsing And Execution Memory Management
7. Since JavaScript And Node.js Are Very Popular , V8 Have A Hard Task
8. To Be A Super Fast Interpreter For A Dynamic Type Language
9. Let’s talk about compilers, interpreters, dynamic and static type languages
10. 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
11. Compilers Interpreters Execution Overhead Efficient Memory Usage Platform Specific Optimizations Why Compilers Perform Better than interpreters
12. Dynamic Type Languages Have To Do Those Techniques At Runtime • Runtime Type Checking • Dynamic Dispatch
13. Compiler, static typed language == Interpreter, dynamic type language == == Interpreter, dynamic type language So In Most Cases
14. To Make V8 Super Fast, 2 Compilers And One Interpreters To The Rescue
15. • Ignition Interpreter • Turbofan Compiler • Sparkplug Compiler
16. Code Parsing Pipeline - Evolution
17. What’s Happening When Your Application Code Is Running ?
18. Parser And AST
19. function add(a,b) { return a+b; } Simple AST Example
20. Ignition Interpreter
21. Turbofan Compiler - JIT Compiler
22. Help turbofan work fast - Use fewer function input type variations
23. monomorphic(myNumber : number) : void;
24. polymorphic(myNumber : number) : void; polymorphic(myString: String) : void;
25. megamorohic(myNumber : number) : void; megamorohic(myString: String) : void; megamorohic(myPerson : Person) : void; megamorohic(myFirstAray: Array<String>) : void; megamorohic(mySecondArray: Array<number>) : void;
26. Optimization And De-Optimization
27. De-Optimization - Example class Person { constructor(name, age) { this.name = name; this.age = age; } } function getAge(person) { return person.age; }
28. 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); }
29. De-Optimization - Example const differentPerson = new Person("Tamar", 30);; // Adding dynamic property, hidden class changed differentPerson.salary = 3000; //binary released getAge(differentPerson);
30. • Assumption for turbofan optimizations - checking the Shape as a prerequisite • The “maps check” checks what hidden class the object is pointing to and makes sure it is the same as the compiler expects. • If it matches, then the check succeeds; if not, then it fails and the code is deoptimized due to “wrong map.” De-Optimization - Wrong “Hidden Class”
31. Deoptimization Benchmark
32. Optimized Code function concat_str(arg) { return arg + arg; } // Start for (let i = 0 ; i< 100000; i++) { concat_str("a"); } // End
33. 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
34. Test Results - 100,000 Loop
35. Lets See The Performance Effect On 10,000,000 Loop Iterations
36. Test Results - 10,000,000 Loop
37. Comparing Runs
38. node --trace-opt --trace-deopt myProgram.js
39. What I Got When Running With Those Flags ?
40. First Phase - 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]
41. Phase 2 - Optimizing Again [compiling method 0x070b4aa61039 <JSFunction concat_str (sfi = 0x3dc4dce32bb1)> (target TURBOFAN) using Turbofan] [marking 0x070b4aa60601 <JSFunction (sfi = 0x3dc4dce32af9)> for optimization to TURBOFAN, ConcurrencyMode::kConcurrent, reason: hot and stable] [optimizing 0x151588782981 <JSFunction concat_str (sfi = 0x3dc4dce32bb1)> (target TURBOFAN) - took 0.000, 0.458, 0.000 ms] [completed optimizing 0x151588782981 <JSFunction concat_str (sfi = 0x3dc4dce32bb1)> (target TURBOFAN)] [compiling method 0x1515887829c1 <JSFunction (sfi = 0x3dc4dce32af9)> (target TURBOFAN) using Turbofan OSR] [optimizing 0x1515887829c1 <JSFunction (sfi = 0x3dc4dce32af9)> (target TURBOFAN) - took 0.000, 0.584, 0.000 ms] [bailout (kind: deopt-eager, reason: Insufficient type feedback for generic named access): begin. deoptimizing 0x1515887829c1 <JSFunction (sfi = 0x3dc4dce32af9)>, opt id 2, bytecode offset 74, deopt exit 7, FP to SP delta 112, caller SP 0x00016bc4a310, pc 0x000128853888]
42. Let’s Go Back To V8 Code Parsing Pipeline
43. What Needs Improvement ?
44. • Application start • Command line application • Dynamic environment with de-optimizations Week Scenarios
45. Turbofan Helps When Your Application Is Already “Warm”, But What if it is Not The Case Yet ?
46. So This Pipeline Turned Into …
47. V8 New Architecture - Mid Tier Compiler
48. 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
49. 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
50. Ignition Does The Hard Work • variable resolution • parentheses or arrow functions • desugaring destructuring statements
51. // The Sparkplug compiler for (; !iterator.done(); iterator.Advance()) { VisitSingleBytecode(); } Transfer Over The Code In A For Loop, No IR
52. SparkPlug Real World Performance Improvement
53. Improve Class Initializations
54. So , How JavaScript Objects Are Built Behind The Scenes ?
55. JavaScript Objects
56. JavaScript Arrays
57. Shapes To Represent Object Types
58. The Offset Lookup Was Very Expensive
59. The Solution - The Inline Cache
60. Monomorphic, Polymorphic, Megamorphic - And the effect of the inline cache
61. 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
62. Until recent V8 versions - Inline Cache was not implemented for class fields and private methods
63. const person = {}; person.age = 42; class Person { age; constructor(age) { this.age = age; } getAge() { return this.age; } }
64. Benchmark - Class Initialization In Previous And Latest Node.js Versions
65. Benchmark Setup class Person { age; constructor(age) { this.age = age; } function getAge(person) { return person.age; } }
66. Benchmark Phase 1 arr = []; // Start for (let i = 0 ; i < 1000000 ; i++ ) { const p = new Person(30); arr[i] = p; } // End
67. Benchmark Phase 2 // Start for (let i = 0 ; i < 1000000 ; i++ ) { arr[i].age; } // End
68. Test Results
69. Class Field Initialization Improvement
70. What’s In It For Me ? class Person { age; constructor(age) { this.age = age; } getAge() { return this.age; } }
71. Type Schema Validation
72. Tamar Twena-Stern twitter @SternTwena linkedin /tamarstern tamar.twena@gmail.com