Node.js uses the V8 JavaScript engine and the libuv library. V8 compiles JavaScript to machine code for high performance, while libuv provides asynchronous I/O capabilities. Node.js initializes V8, wraps libuv, and provides a module system to load code, with modules defined as functions that export values. Native modules can extend Node.js using NAN or the newer N-API for direct access to V8 from C/C++ code.

1. V8 + libuv = Node.js
Under the hood
Юрий Шевцов

2. Все познается в
сравнении

3. int func2(int arg1, char *arg2) {
char str[100];
/* some other expressions */
}
int func1() {
int foo = 0;
int bar = 3;
char* buzz = malloc(5);
func2(foo, buzz);
}
char* buzz (stack slot with
address)
int bar = 3
int foo = 3
Return address
Params of func1
Stack

4. int func2(int arg1, char *arg2) {
char str[100];
/* some other expressions */
}
int func1() {
int foo = 0;
int bar = 3;
char* buzz = malloc(5);
func2(foo, buzz);
}
str[99]
str[1] … str[98]
str[0];
Return address (line 10)
arg2 = buzz
arg1 = foo = 3
Data of func1
Stack

5. Stackframe
● Arguments
● Local variables
● Return address

7. Everything is object on the Heap

8. for (let i = 0; i < 42; i++) {}
foo[1]
foo[231]
Except SMI (Small integers)
2 42
570
200

9. Tagged pointer
32nd bit 1st bit
Data bits
T == 0 - SMI
T == 1 - Pointer T X X X X X ... X X X X X X

10. Object
representation
Hashtable
VS
Optimised View

11. Closer look
JSObject
Map
Extra Properties
Elements
Property “a”
Property “b”
FixedArray
Map
Length
Property “c”
Property “d”
FixedArray
Map
Length
Property “1”
Property “2”
Property “3”

12. 32 Slots and extra properties
1. Object gets 32 slots
2. V8 trims unused slots later
3. Extra properties go separately

13. Elements
● Keys are array indices
● Elements may be represented as simple
array
● Unbox values, if numbers only

14. Map a.k.a Hidden Class
● Stores object layout ({ property: offset })
● Assignment order matters
● New map created for each object change
● Allows fast property lookup

15. Maps creation
function Foo(bar, buzz) {
this.bar = bar;
this.buzz = buzz;
}
const foo1 = new Foo(1, 2);
const foo2 = new Foo(3, 4);
foo1.some = 5;
{ } - C0
{ bar } - C1
{ bar, buzz } - C2
{ bar, buzz, some } - C3

16. Inline caching

17. Heap Structure
New-space Old-space And more...

18. Garbage collection
Scavenge | Mark & sweep

19. Mark

20. Compact

22. Asynchronicity
<script type="text/javascript">
setTimeout(() => console.log(1));
Promise.resolve().then(() => console.log(2));
</script>

23. Two standards
VS
ECMAScript WHATVG

24. Task types
Tasks:
setTimeout, requestAnimationFrame, I/O, UI
rendering
Microtasks:
Promises, process.nextTick, MutationObserver

25. Event loop algorithm
1. Run task till completion
2. Run microtasks
3. Run microtask scheduled by another
microtask

26. Correct answer
2
1
Hint: running script is also a task

27. V8 compilers
Before
Full-codegen - generates unoptimized machine code
Crankshaft - optimizes hot functions

28. V8 compilers
Ignition - generates bytecode
Turbofan - optimizes, using Sea-of-Nodes graph
interpreter + compiler

29. V8 is a library

30. Bare V8 runs scripts
Isolate* isolate = Isolate::New()
Local<Context> context = Context::New(isolate)
Local<String> source = String::New(isolate, "'Hello , World!'")
Local<Script> script = Script::Compile(context, source)
Local<Value> result = script->Run(context)

31. V8 API terminology
Isolate - instance of V8 VM
Context - holds pristine copy of global object
Local<?> - handle for JS object in heap

32. Two templates
Functions
Objects

33. Function Template
void LogCallback(FunctionCallbackInfo<Value>& args) {}
global->Set("log", FunctionTemplate::New(isolate, LogCallback));

34. Object Template
Interceptors Accessors

35. Example
global_templ->SetAccessor("foo", XGetter, XSetter);
void XGetter(Local<String> property) {
info.GetReturnValue().Set(x);
}
void XSetter(Local<String> property, Local<Value> value) {
x = value->Int32Value();
}
Local<ObjectTemplate> global = ObjectTemplate::New(isolate);

37. do {
uv__update_time(loop);
uv__run_timers(loop);
uv__run_idle(loop);
uv__run_prepare(loop);
uv__io_poll(loop, timeout);
uv__run_check(loop);
uv__run_closing_handles(loop);
} while (uv__loop_alive(loop))

40. Node.js is...
● V8 initializer
● libuv wrapper
● Module loader

41. Your module is a function
NativeModule.wrap = function(script) {
return NativeModule.wrapper[0]+script+NativeModule.wrapper[1];
};
NativeModule.wrapper = [
'(function (exports, require, module, __filename, __dirname) { ',
'n});'
];

42. Native modules
NAN vs N-API

43. Спасибо за внимание!