Cog VM Evolution. Clément Béra. Thursday, August 25, 16

Transcription

1 Cog VM Evolution Clément Béra

2 Cog VM? Smalltalk virtual machine Default VM for Pharo Squeak Newspeak Cuis

3 Cog Philosophy Open source (MIT) Simple Is the optimization / feature worth the added complexity? Cross-Platform (Processors, OS, 32/64 bits)

4 Execution engine VM Execution engine Plugins: graphics, file, etc.

5 Execution engine Interpreter JIT Memory Manager (including GC)

6 Evolution User and Customer driven Where did we start? What problems did we solve?

7 Starting blocks Interpreter VM Made by Dan Ingalls Team Simple Interpreter Spaghetti stack Smart but simple Memory Manager

8 Performance! Short-term delivery Performance for 3D application

9 Performance! Short-term delivery Performance for 3D application Fast Interpreter

10 Stack VM Context-to-stack Mapping 85% of context allocation removed No copying of arguments New hash logic Primitive function caching

11 Issue Closure implementation No temporaries BlockAlreadyEvaluated error Non obvious bugs New implementation

12 Binary Tree benchmark Interpreter Stack Cog V1 Cog V2 Spur Sista

13 More Performance! Short-term delivery Performance for 3D application

14 More Performance! Short-term delivery Performance for 3D application First JIT compiler

15 Cog VM x86 back-end Simple machine code generation Except inline caches

16 Binary Tree benchmark Interpreter Stack Cog V1 Cog V2 Spur Sista

17 JIT Abstractions Machine back-end x86 Object Representation V3 Cogit Implementation SimpleStackCogit

18 Yet More Performance! Short-term delivery Performance for 3D application

19 Yet More Performance! Short-term delivery Performance for 3D application Second JIT compiler

20 Cog VM Machine code generation Linear scan register allocation Avoids many stack operations Register-based calling convention

21 Binary Tree benchmark Interpreter Stack Cog V1 Cog V2 Spur Sista

22 JIT Abstractions Machine back-end x86 Object Representation V3 Cogit Implementation SimpleStackCogit StackToRegisterMappingCogit

23 Newspeak support? Newspeak is Smalltalk-like New kind of sends

24 Newspeak support? Multiple bytecode set support Newspeak specific operations Interpreter Machine code generation

25 64 bits? Images larger than 1 or 2 Gb? Moving objects during FFI call-backs? Even more performance! Ephemerons? Become is so slow it cannot be used.

26 64 bits? Images larger than 1 or 2 Gb? Moving objects during FFI call-backs? Even more performance! Ephemerons? Become is so slow it cannot be used. Short-term delivery

27 64 bits? Images larger than 1 or 2 Gb? Moving objects during FFI call-backs? Even more performance! Ephemerons? Become is so slow it cannot be used. Short-term delivery New Memory Manager

28 Spur Memory Manager Class-table (efficient caches and compactness) Efficient scavenging Fast become Pinned objects Segmented Memory New object layouts (Ephemerons, ShortArrays) Memory representation 64-bits compatible

29 Binary Tree benchmark Interpreter Stack Cog V1 Cog V2 Spur Sista

30 JIT Abstractions Machine back-end x86 Object Representation V3 Spur32 Cogit Implementation SimpleStackCogit StackToRegisterMappingCogit Spur64 32 bits 64 bits

31 Raspberry Pi performance? Scratch support

32 Raspberry Pi performance? Scratch support ARMv6 support

33 ARMv6 support JIT ARMv6 back-end JIT abstraction over literal management JIT abstraction over CISC / RISC

34 JIT Abstractions Machine back-end Object Representation Literal Manager Cogit Implementation x86 ARMv6 MIPSEL V3 Spur32 Spur64 Inline Outline SimpleStackCogit StackToRegisterMappingCogit 32 bits 64 bits

35 Ryan (contributor) Working with the Dart VM Dart runs on more platform than Newspeak.

36 Ryan (contributor) Working with the Dart VM Dart runs on more platform than Newspeak. MIPSEL support

37 JIT Abstractions Machine back-end Object Representation Literal Manager Cogit Implementation x86 ARMv6 MIPSEL V3 Spur32 Spur64 Inline Outline SimpleStackCogit StackToRegisterMappingCogit 32 bits 64 bits

38 64 bits support? 64 bits library binding Heap over 2Gb

39 64 bits support? 64 bits library binding Heap over 2Gb x64 support Immediate float

40 JIT Abstractions Machine back-end Object Representation Literal Manager Cogit Implementation x86 ARMv6 MIPSEL x64 V3 Spur32 Spur64 Inline Outline SimpleStackCogit StackToRegisterMappingCogit 32 bits 64 bits

41 Yet even more performance! Computation lasting 3 to 6 hours

42 Yet even more performance! Computation lasting 3 to 6 hours Speculative optimizations

43 Sista VM The program introspects Optimize the code for performance Deoptimize when it took incorrect decisions

44 Issues Bytecode set Literal mutability Closure implementation

45 Bytecode set limitations? Code generator tools

46 Sista bytecode set Lifting encoding limitations Encode instructions for the Sista / Lowcode

47 Efficient modification trackers? Literal inconsistency?

48 Efficient modification trackers? Literal inconsistency? Read-only objects IWST talk this afternoon Hopefully allows more compiler optimizations

49 Closure implementation Method and closure get more similar Simplifies part of the VM Simplifies the runtime compiler

50 Integration Closed alpha version Integrating dependencies: Bytecode set integrated Read-only objects integrated (but disabled) Closure implementation in progress

51 Binary Tree benchmark Interpreter Stack Cog V1 Cog V2 Spur Sista

52 JIT Abstractions Machine back-end Object Representation Literal Manager Cogit Implementation x86 ARMv6 MIPSEL x64 V3 Spur32 Spur64 Inline Outline SimpleStackCogit StackToRegisterMappingCogit RegisterAllocatingCogit SistaCogit 32 bits 64 bits

53 Image compaction? Sometimes, large images when saving

54 Image compaction? Sometimes, large images when saving Better compactor

55 Pauses? 0.5 second freezes in UI application

56 Pauses? 0.5 second freezes in UI application Incremental GC

57 Many hidden parts...

58 C compiler warning? C generated from Slang Many were fixed Towards compilation with -WAll -WError

59 Faster arithmetic? LargeInteger plugin more efficient Computation moved from 8bits to 32 bits Different compilation flags

60 Slang? Slang-to-C compiler Many improvements Type inference

61 Contribution

62 Cog VM team Started with Eliot Miranda Many more contributors now: Tim Rowledge Clément Béra (myself) Nicolas Cellier Fabio Niephaus & Tim Felgentreff Ryan Macnak

63 Conclusion Lots of new features and improvements over years A lot more is incoming If you want to support, talk to us! ARMv8? Incremental GC? Performance (escaping, floats)?