Turbocharging JavaScript: V8

Rahul DéCompiler Junkie @ThoughtWorks

ProblemFind the 25, 000th Prime number

JavaScript

The LanguageInvented by Brendan Eich at Mozilla Research.

Defined by the ECMA 262 Standard - ECMAScript 6.

Dynamically Typed.

Duck Typing.

Prototype and Object based.

Asynchrony is a language feature.

Functions are first class citizens.

Has its fair share of the Good, the Bad and the Ugly.

Implementing the Good, Bad and the Ugly.

Major JavaScript Implementations

SpiderMonkey, IonMonkey and JägerMonkey JIT compilers by Mozilla powering Firefox.

V8 by Google powering the Chromium family of Browsers, Opera, Node.js, MongoDB etc.

JSCore by Apple powering Safari and WebKit based browsers.

Rhino/Nashorn by Mozilla Research and Oracle implement JavaScript in the JVM.

Fully Compiled Languages

C, C++, Pascal, Fortan etc…

Tokenizer Parser Optimiz

erGramm

ar

Code Gen

Assembly Code

Tokens AST IR

Abstract Syntax Treehttp://jointjs.com/demos/javascript-ast

Intermediate Representation

int a = 5;int b = 10;

int c = a + b;

stor a, 5mov r1, astor b, 10

mov r2, 10add r1, r2store c, r1

Assembly Language

mov rax, 05Hmov rbx, 0AHadd rax, rbx

mov rax, [1000]

Partly Compiled LanguagesJava, Python, Ruby

etc.

Tokenizer Parser Optimiz

erGramm

ar

Code Gen Byte Code

Tokens AST

VM

Byte Codes

a = 5;b = 10;

c = a + b;

iconst 5set a

iconst 10set b

push apush b

addset c

Virtual Machines

Stack VM - JVM, Python VM, Ruby VM(YARV) etc.

Register VM - Dalvik VM, Lua VM, LLVM etc.

Running Byte codesiconst 5

set aiconst 10

set bpush apush b

addset c

5pop10popa

a ba + bpop

a = 5

b = 10

c = 15

Problems??A full program executes them

Lot of context switching

A big switch case to dispatch the byte codes

Big libs to handle the ops

But, necessary as its a dynamic language and makes it cross platform

JIT VMJVM, CLR, V8

Tokenizer Parser Optimiz

erGramm

ar

Code Gen Byte Code

Tokens AST

VM JIT

JITiconst 5

set aiconst 10

set bpush apush b

addset c

mov rax, 05Hmov rbx, 0AHadd rax, rbx

mov rax, [1000]At Runtime

Whycode directly executes on CPU hence MUCH faster

no need of complex slow code to dispatch byte codes

more efficient execution with lesser machine resources used.

Enables much more runtime optimizations

but is quite difficult to implement

Can JavaScript ever be faster than C++?

FeaturesNO BYTECODES!

Full Register JIT

Advanced runtime/compile time optimizations

Highly embeddable

Implements the full ES6 spec

Architecture and Design

Compiler Full Code Gen Crankshaft

Compiler

Hydrogen DFG Lithium IR

Optimized Code Gen

Inline Caches

CompilerReads the JavaScript source.

Tokenizes, Parses and checks for syntax errors.

Produces a persistant AST or pAST.

Very VERY fast.

Full Code GenReads the AST

Blindly generates platform specific assembly code.

Generates some extra code to infer types called inline caches (IC).

Dispatches whole code to CPU directly.

Very VERY VERY fast.

Inline Caches (IC)

function add(a, b) { return a + b;}

add(5, 6)

add(“5”, 6)add(“Rahul”, “Dé”)

int, int -> intstr, int -> strstr, str -> str

asm1asm2asm3

Call Sites

Crankshaft CompilerProfiles the CPU performance via a thread.

Gathers type info from the ICs.

Generates the Hydrogen representation for advanced optimizations

From that generates platform specific Lithium IR for register allocation with more optimizations.

Finally super fast, optimized assembly is generated and is set free on the CPU.

De-optimizes wrongly optimized code to full code gen level.

Crankshaft is slower than others as it does a lot of analysis.

Hydrogen DFGDerived from type info from the ICs.

Is a Acyclic Data Flow Graphical Representation of the pAST.

Enables advanced optimizations like hotspots, unreachable code, peep hole, loop invariant code motions etc.

Used to generate the platform specific Lithium code.

Lithium IRIs a three address register representation of the Hydrogen DFG

Enables low level optimizations like register reduction

Maps exactly to the underlying architecture to maximize faster code gen.

Used to generate the fast optimized native assembly code.

Possible Future of V8Ignition Compiler

Much faster and produces streamlined, compact byte codes which saves a lot of memory with at par perf.

Turbofan Engine

Reads the ignition byte codes and JITs directly with blazing fast speed while reducing memory footprints.

Replace the pAST, full code gen and crankshaft with the ignition and turbofan compilers.

Already in pre Alpha builds.

Can I help V8 to execute my code better??

Of course. By now you know a lot about V8. And definitely you can

now write much better code.

Writing V8 friendly JavaScript.

Hidden Classes

function Point(x, y) { this.x = x; this.y = y;}

var p1 = new Point(5, 6);var p2 = new Point(7, 8);

xy

x 5y 6

x 7y 8

Hidden Classes

var p1 = new Point(5, 6);p1.z = 4;delete p1.z;

xy

xyz

x 5y 6z 4

Performance TipsTry to use homogeneous data types in Arrays.

Pre allocate arrays if non homogeneous data is needed.

Avoid pushing non homogenous types like bools into int arrays.

Initialize Function objects instead of pushing in attributes later on.

Catch blocks are not crankshaft optimizable, write the catch code in a function and call it from the catch block.

Turbocharging JavaScript

Fixing the ProblemFind the 25, 000th Prime number

Thank you.rahul080327@gmail.com

https://github.com/rahul080327