This is presentation from WG.NET (May 2019), where I'm discussing different aspects of virtualization, mainly in the context of programming languages. We'll covering up what stack vs. register based virtual machines are, what is interpreter and compiler and how to build our own bytecode interpreter for a toy programming language.

1. VIRTUAL MACHINES
HOW DO THEY WORK? DO THEY WORK? LET’S FIND OUT!

2. INTRODUCTION
Bartosz Sypytkowski
▪ @Horusiath
▪ b.sypytkowski@gmail.com
▪ bartoszsypytkowski.com

3.  What virtual machines are all about.
 Stack vs Register based VMs
 Bytecode and interpreters
 Demo
AGENDA

4. MOTIVATION

5. VIRTUAL
MACHINE

6. SYSTEM VIRTUAL
MACHINE
PROCESS VIRTUAL
MACHINE

7. STACK
VS.
REGISTER

8. STACK
const.i32 3
const.i32 2
add.i32
Stack

9. STACK
const.i32 3
const.i32 2
add.i32
Stack
3

10. STACK
const.i32 3
const.i32 2
add.i32
Stack
2
3

11. STACK
const.i32 3
const.i32 2
add.i32
Stack
3
2
5

12. ACTIVATION
FRAMES arity
return address
function arg0
Activation
frame fib(5)
arity
return address
function arg0
Activation
frame fib(4)
Frame
pointer

13. BYTECODE

14. 20 00 42 00 51 04 7e
42 01 05 20 00 20 00
42 01 7d 10 00 7e 0b
TEXT FORMAT BINARY FORMAT
get_local 0
i64.const 0
i64.eq
if i64
i64.const 1
else
get_local 0
get_local 0
i64.const 1
i64.sub
call 0
i64.mul
end

15. WHY NOT AST?

16. Intermediate representations
1. .NET CIL
2. JVM bytecode
3. WASM
4. LLVM IR
5. MemSQL bytecode
BYTECODE

17. INTERPRETER
VS.
COMPILER

18. ASSEMBLY NOT LOW-LEVEL LANGUAGE ANYMORE

19. BUT SERIOUSLY…
WHO USES BYTECODE INTERPRETER ON PROD?

20. COMPAR
ING
VECTOR
CLOCKS
CASE
STUDIES
• pre 1.9 – AST interpreter
• v1.9 (25 Dec 207) – YARV: bytecode interpreter
• v2.6 (25 Dec 2018) – JIT (experimental)
RUBY MRI
CPYTHON
• ATM still bytecode interpreted
• Bytecode generated and cached in .pyc files

21. MULTI TIER
CODE
EXECUTION
TIME
Query
parsing
interpreter
compiler
execution
execution
Switch
point
compilation

22. DEMO

23. A MINIMAL
VIRTUAL
MACHINE
1. Program to execute
2. Instruction counter / program counter
3. Virtual stack (LIFO)
4. Stack pointer
5. Frame pointer

24. REMARKS 1. Not optimal
2. No debugger
3. No error handling
4. No local/global variables
5. Only one primitive supporter (Int32)

25. SSVM
Bytecode
1. Constant
2. Add
3. Sub
4. Mul
5. JumpIfTrue
6. JumpIfFalse
7. Equal
8. LessThan
9. GreaterThan
10. Call
11. LoadArgument
12. Return
13. Halt
14. Print

26. SAMPLE
PROGRAM
// int fib(n) {
// if(n == 0) return 0;
LoadArgument 0 // 0 - load last function argument N
Constant 0 // 2 - put 0
Equals // 4 - check equality: N == 0
JumpIfFalse 10 // 5 - if they are NOT equal, goto 10
Constant 0 // 7 - otherwise put 0
Return // 9 - and return it
// if(n < 3) return 1;
LoadArgument 0 // 10 - load last function argument N
Constant 3 // 12 - put 3
LessThan // 14 - check if 3 is less than N
JumpIfFalse 20 // 15 - if 3 is NOT less than N, goto 20
Constant 1 // 17 - otherwise put 1
Return // 19 - and return it
// else return fib(n-1) + fib(n-2);
LoadArgument 0 // 20 - load last function argument N
Constant 1 // 22 - put 1
Sub // 24 - calculate: N-1, result is on the stack
Call fib 1 // 25 - call fib function with 1 arg. from the stack
LoadArgument 0 // 28 - load N again
Constant 2 // 30 - put 2
Sub // 32 - calculate: N-2, result is on the stack
Call fib 1 // 33 - call fib function with 1 arg. from the stack
Add // 36 - since 2 fibs pushed their ret values on the stack, just add them
Return // 37 - return from procedure
// entrypoint - main function
Constant 6 // 38 - put 6
Call fib 1 // 40 - call function: fib(arg) where arg = 6;
Print // 43 - print result
Halt // 44 - stop program

27. Virtual Machine
typedef struct {
int* code; // program opcodes
int* stack; // virtual stack
int pc; // program counter
int sp; // stack pointer
int fp; // frame pointer
} VM;
// push value on top of the stack
#define PUSH(vm, v) vm->stack[++vm->sp] = v
// pop value from top of the stack
#define POP(vm) vm->stack[vm->sp--]
// get next bytecode
#define NEXT(vm) vm->code[vm->pc++]
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer

28. Interpreter Loop
void (*op_handles[])(VM*) = {
// opcode function pointers
};
void vm_run(VM* vm) {
do {
int opcode = NEXT(vm);
if (opcode == Halt) {
return;
}
op_handles[opcode](vm);
} while(1);
}

29. Constant X
void op_constant(VM* vm) {
int x = NEXT(vm);
PUSH(vm, x);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer

30. Constant X
void op_constant(VM* vm) {
int x = NEXT(vm);
PUSH(vm, x);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
x

31. Constant X
void op_constant(VM* vm) {
int x = NEXT(vm);
PUSH(vm, x);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
x

32. Print
void op_print(VM* vm) {
int x = POP(vm);
printf(“%dn”, x);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
x

33. Print
void op_print(VM* vm) {
int x = POP(vm);
printf(“%dn”, x);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
x

34. Print
void op_print(VM* vm) {
int x = POP(vm);
printf(“%dn”, x);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
x
STDOUT

35. Add / Sub / Mul / Div
void op_add(VM* vm) {
int b = POP(vm);
int a = POP(vm);
//TODO: check overflow
PUSH(vm, a + b);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a
b

36. Add / Sub / Mul / Div
void op_add(VM* vm) {
int b = POP(vm);
int a = POP(vm);
//TODO: check overflow
PUSH(vm, a + b);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a
b

37. Add / Sub / Mul / Div
void op_add(VM* vm) {
int b = POP(vm);
int a = POP(vm);
//TODO: check overflow
PUSH(vm, a + b);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a
b

38. Add / Sub / Mul / Div
void op_add(VM* vm) {
int b = POP(vm);
int a = POP(vm);
//TODO: check overflow
PUSH(vm, a + b);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a + b

39. Equal / Less / etc.
void op_eq(VM* vm) {
int b = POP(vm);
int a = POP(vm);
PUSH(vm, a == b ? 1 : 0);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a
b

40. Equal / Less / etc.
void op_eq(VM* vm) {
int b = POP(vm);
int a = POP(vm);
PUSH(vm, a == b ? 1 : 0);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a
b

41. Equal / Less / etc.
void op_eq(VM* vm) {
int b = POP(vm);
int a = POP(vm);
PUSH(vm, a == b ? 1 : 0);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
a
b

42. Equal / Less / etc.
void op_eq(VM* vm) {
int b = POP(vm);
int a = POP(vm);
PUSH(vm, a == b ? 1 : 0);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
1

43. Conditional
Branches
void op_jmp_eq(VM* vm) {
int address = NEXT(vm);
if (POP(vm)) {
vm->pc = address;
}
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
1

44. Conditional
Branches
void op_jmp_eq(VM* vm) {
int address = NEXT(vm);
if (POP(vm)) {
vm->pc = address;
}
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
1
addr

45. Conditional
Branches
void op_jmp_eq(VM* vm) {
int address = NEXT(vm);
if (POP(vm)) {
vm->pc = address;
}
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
1
addr

46. Conditional
Branches
void op_jmp_eq(VM* vm) {
int address = NEXT(vm);
if (POP(vm)) {
vm->pc = address;
}
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
addr

47. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer

48. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr

49. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr
argc

50. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr
argc

51. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr
argc
fp

52. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr
argc
fp
pc

53. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr
argc
fp
pc
activation
frame

54. Call
void op_call(VM* vm) {
int addr = NEXT(vm);
int argc = NEXT(vm);
PUSH(vm, argc);
PUSH(vm, vm->fp);
PUSH(vm, vm->pc);
vm->fp = vm->sp;
vm->pc = addr;
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
addr
argc
fp
pc

55. LoadArgument
void op_lda(VM* vm) {
int argx = NEXT(vm);
int v = vm->stack[vm->fp-argx-3];
PUSH(vm, v);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc

56. LoadArgument
void op_lda(VM* vm) {
int argx = NEXT(vm);
int v = vm->stack[vm->fp-argx-3];
PUSH(vm, v);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc
argx

57. LoadArgument
void op_lda(VM* vm) {
int argx = NEXT(vm);
int v = vm->stack[vm->fp-argx-3];
PUSH(vm, v);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc
v
frame pointer – 3 - argx

58. LoadArgument
void op_lda(VM* vm) {
int argx = NEXT(vm);
int v = vm->stack[vm->fp-argx-3];
PUSH(vm, v);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc
v

59. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc
result

60. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc
result

61. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
pc
result

62. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
fp
result

63. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
argc
result

64. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
arg0
result

65. Return
void op_ret(VM* vm) {
int result = POP(vm);
vm->pc = POP(vm);
vm->fp = POP(vm);
int argc = POP(vm);
vm->sp -= argc;
PUSH(vm, result);
}
stack
20 00 42
00 51 04
7e 42 01
05 20 00
20 00 42
01 7d 10
00 7e 0b
code
stack pointer
program pointer
frame pointer
result

66. SUMMARY

67.  Crafting interpreters: https://craftinginterpreters.com/contents.html#a-bytecode-virtual-machine
 Register-based VM: https://github.com/skx/simple.vm
 Konrad Kokosa: “Pro .NET Memory Management”
 Database query compilation: https://www.youtube.com/watch?v=baOAbOdcnxs
 Adding new CIL instruction to .NET: https://mattwarren.org/2017/05/19/Adding-a-new-Bytecode-
Instruction-to-the-CLR/
 and many many more…
REFERENCES

68. THANK YOU