inside javascript's core - part 1

In my previous article we talked about what Javascript is. In this article I want to go deeper and start exploring how Javascript works focusing on the most famous Javascript engine: Google’s V8.

An "engine" is a self-contained, but externally-controllable, piece of code that encapsulates powerful logic designed to perform a specific type of work.

Every major browser comes with one already built-in…

• Firefox uses SpiderMonkey (the first ever Javascript engine)
• Safari uses JavascriptCore
• Edge used to use Chakra (now it uses the Blink and V8)

and so on…

In this series I am going to talk about the V8 and today I will talk about Garbage Collection.

But, first a quick introduction.

What is this V8 thing?

V8 is Google’s open source high-performance JavaScript and WebAssembly engine

It is written in C++ and it is embedded in Open Source projects like NodeJs and Deno.

It is what provides all the data types, operators, objects and functions.
It is what manages the memory of a Javascript program.
It is what optimizes the code to run faster.
It is what makes the thing you write, happen.

💡 - Did you know you can access V8 native syntax in NodeJs by passing the —allow-natives-syntax-flag?

Open Source

Implements ECMAScript

ECMA (European Computer Manufacturer’s Association) is an association that develops standards for technologies. ECMA-262 is a standard that contains the specification for a general purpose scripting language. This specification is called ECMAScript.

A standard is a document that provides rules, guidelines or characteristics for activities or their results, for common and repeated use. Standards are created by bringing together all interested parties including manufacturers, users, consumers and regulators of a particular material, product, process or service.

💡 - Scripting vs Programming

Manages Javascript Memory

Allocation —> Usage —> Release

Some languages require a manual allocation and release of memory

int* ptr;
ptr = new int; // Dynamically allocating memory for an int variable
*ptr = 12;

cout << *ptr << endl;
delete ptr; // Deallocate memory

Javascript does not.

So, how in the hell does Javascript handle memory?

Heap and Stack

Javascript engines have two places where they store data: the heap and the stack.

We can simply define the stack as the place where static data, including method and function frames primitives data types and pointers to objects get stored, while the memory heap is the place where the non primitves data types are stored. The Heap is where Garbage Collection takes place.

All variables first point to the stack. If it is not a primitive value, the stack contains a reference that points to the Object in the heap.

💡 - Why can I push elements in const Arrays ?

Garbage Collector

When we write our code and create primitives, objects, functions we just learned that it takes memory. So when is the cleaning performed?
In Javascript the engine does all the hard work for us.

The way V8 achieves that is through the implementation of some advanced concepts.

Reachability

If an object is currently reachable within the runtime must be kept, and any unreachable objects may be collected.

Marking

Marking is the process by which reachable objects are found

Sweeping

Sweeping is a process where gaps in memory left by dead objects are added to a data structure called a free-list.

A free list is a data structure generally used for dynamic memory allocation that connects unallocated regions of memory together in a linked list.
When new data has to be allocated, V8 looks at the free list to find an appropriate chunk of memory.

Compaction

Compaction is the process of copying surviving objects into other pages that are not currently being compacted (using the free-list for that page)

Although you do not need to worry about freeing memory everytime, this doesn’t exempt you from carefully reviewing your code.
Things such as badly implemented recursion or infinite loop can extinguish your available memory pretty quick and/or worse lead to memory leaks.

Generations

V8 splits the heap into different regions called Generations.

• Young Generation - split further in Nursery and Intermediate
• Old Generation

Starting from the nursery, if an object survive a Garbage Collection it is moved into Intermediate generation at first and then, after another survival to Old Generation.

But why is that?

Most objects die young

Rememebering the concept of Compaction and assuming that objects are more likely to die in initial generations, then by moving only the objects that survive, V8 only pays a cost for copying that is proportional to the number of the surviving objects… and not the number of their allocations.

Orinoco is the codename of the Garbage Collector project to make use of the latest and greatest parallel, incremental and concurrent techniques for garbage collection, in order to free the main thread

Geez, what does that even mean?
Well, one metric in measuring the Garbage Collection is the time that the main thread spends paused while GC is performed.

In traditional Stop The World garbage collectors this time can add up and become a burden on user experience (latency or poor rendering), this is why Orinoco introdcued 3 techniques to make the collection more powerful.

1. Parallel: is where the main thread and the helper threads divide, almost equally, the work. This is still stop the world approach but the pause time is now divided for the number of threads participating. There is no Javascript running.
2. Incremental: the main thread doesn’t do an entire Garbage Collection, but just a small amount of work intermittently. This is more difficult because Javascript executes between each segment meaning that heap changes and thus giving birth to the risk of invalidating all the previous work done by GC.
3. Concurrent: is where the main thread executes Javascript with no interruptions while the helper thread does Garbage Collection in the background. This has a similar risk to the Incremental GC techinque, plus constant races between the main and the helper thread to read/write objects.

V8’s stop-the-world, generational, accurate garbage collector is one of the keys to V8’s performance.

Conclusion

References