Ruby VM Internals: TMI

RubyConf 2015 talk.

Transcript

2. JavaScript
3. Everything is broken.
4. Ruby VM Internals The TMI Edition
5. Aaron Patterson
6. @tenderlove
10. Ruby Core Team Rails Core Team
11. I am bad at saying "no"
14. ☁
15. https://github.com/ManageIQ/ manageiq
16. RubyConf 5k
17. TEXAS!!!
19. Stupid Ruby VM Tricks
20. Stupid Ruby VM Tricks
21. Stupid Ruby VM Tricks
22. Ruby’s Virtual Machine and its internals
23. WARNING: THIS IS A TECH TALK
24. &&&&&
25. Ruby’s Virtual Machine and its internals
26. Actually a talk about Failure.
27. Building an AOT Compiler
28. Rebrand Failure as: "Potential For Success"
29. Time Breakdown of "Feeling Successful" 1% 9% 11% 11% 31% 37% Fail Fail Fail Fail Fail Success
30. At least I learned something, right?
31. NO
33. ruby myprogram.rb
34. Stuff that happens before the program runs Running the actual program eval
35. Stuff that happens before the program runs Running the actual program Lexer Virtual Machine About 2 Slides Each Parser Compiler Most of Our Time
36. Lexer
37. DOT name: 'each' DO END array.each do; end name: 'array' LEXER
38. Parser
39. Method Call array each block DOT name: 'each' DO END name: 'array' PARSER AST (Abstract Syntax Tree)
40. Hsing-Hui Hsu @SoManyHs 3:05
41. Ruby 1.8 and 1.9 Diverge
42. Ruby 1.8: Interprets AST
43. AST Interpreter Method Call array each block
44. Ruby 1.9+: YARV (VM)
45. put self send array send each Compile Phase Method Call array each block COMPILER
46. What is a Virtual Machine?
47. It’s like a Real Machine, but it’s Virtual.
48. global _start section .text _start: ; write(1, message, 13) mov rax, 1 ; system call 1 is write mov rdi, 1 ; file handle 1 is stdout mov rsi, message ; address of string to output mov rdx, 13 ; number of bytes syscall ; invoke operating system to do the write ; exit(0) mov eax, 60 ; system call 60 is exit xor rdi, rdi ; exit code 0 syscall ; invoke operating system to exit message: db "Hello, World", 10 ; note the newline at the end
49. These are defined by the capabilities of the processor
50. Virtual Machines Give You Freedom
51. What instructions should I dream up today?
52. Two Types of VM: Stack Based & Register Based
53. Stack Based VMs
54. Like a Calculator
55. HP Calculators are RAD
56. 9 * 18
57. 9㾑 18㾑
59. *
61. "That’s so much work, why bother?"
62. GO BACK TO YOUR TI-83 Plus
63. Instructions 9㾑 18㾑 * Stack 1: 9 2: 9 1: 18 1: 162
64. HP 49g+ 9㾑 18㾑 * YARV putobject 9 putobject 18 opt_mult
65. Virtual Machines Should Not Intimidate You
66. C Code Should
67. YARV Code putobject 9 putobject 18 opt_mult Program Just an Array Instruction Parameters
68. So how do we get this "machine code"?
69. Compiler
70. Mult-Pass Compiler
71. AST Linked List Optimizations Byte Code
72. RubyVM::InstructionSequence
73. RubyVM::InstructionSequence ins = RubyVM::InstructionSequence.new <<-eoruby def foo "hello " end puts foo + "world" eoruby puts ins.disasm
74. RubyVM::InstructionSequence == disasm: #<ISeq:<compiled>@<compiled>>================================ 0000 trace 1 ( 1) 0002 putspecialobject 1 0004 putspecialobject 2 0006 putobject :foo 0008 putiseq foo 0010 opt_send_without_block <callinfo!mid:core#define_method, argc:3, ARGS_SIMPLE>, <callcache> 0013 pop 0014 trace 1 ( 5) 0016 putself 0017 putself 0018 opt_send_without_block <callinfo!mid:foo, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache> 0021 putstring "world" 0023 opt_plus <callinfo!mid:+, argc:1, ARGS_SIMPLE>, <callcache> 0026 opt_send_without_block <callinfo!mid:puts, argc:1, FCALL|ARGS_SIMPLE>, <callcache> 0029 leave == disasm: #<ISeq:foo@<compiled>>======================================= 0000 trace 8 ( 1) 0002 trace 1 ( 2) 0004 putstring "hello " 0006 trace 16 ( 3) 0008 leave ( 2)
75. AST
76. What is an AST?
77. "Abstract Syntax Tree"
78. Get the AST NODE* rb_compile_string(const char *f, VALUE s, int line)
79. NODE is an AST Node Method Call array each block
80. Linked List
81. What is a Linked List (LL)?
82. Invented in 1836
83. Battle of the à la Mode
84. Alexander Graham Link
85. Item 1 Item 2 Item 3
86. Linked List Generation VALUE rb_iseq_compile_node(rb_iseq_t *iseq, NODE *node) Our Node Final Product
87. AST Linked List Optimizations Byte Code
88. Which Branch To Follow? VALUE rb_iseq_compile_node(rb_iseq_t *iseq, NODE *node) { DECL_ANCHOR(ret); INIT_ANCHOR(ret); if (node == 0) { COMPILE(ret, "nil", node); iseq_set_local_table(iseq, 0); } else if (nd_type(node) == NODE_SCOPE) {
89. Which Branch To Follow? #define nd_type(n) ((int) (((RNODE(n))->flags & NODE_TYPEMASK)>>NODE_TYPESHIFT))
90. LETS DO SOMETHING DANGEROUS
91. Reach Inside require 'fiddle' include Fiddle func = Function.new Handle::DEFAULT['rb_compile_string'], [TYPE_VOIDP, TYPE_VOIDP, TYPE_INT], TYPE_VOIDP node = func.call "", Fiddle.dlwrap("def foo; end"), 0 p Fiddle.dlunwrap node
92. MUWAHAHAHA $ ruby test2.rb test2.rb:9:in `p': method `inspect' called on unexpected T_NODE object (0x007facab8e6570 flags=0x1) (NotImplementedError) from test2.rb:9:in `<main>'
93. Which Branch To Follow? VALUE rb_iseq_compile_node(rb_iseq_t *iseq, NODE *node) { DECL_ANCHOR(ret); INIT_ANCHOR(ret); if (node == 0) { COMPILE(ret, "nil", node); iseq_set_local_table(iseq, 0); } else if (nd_type(node) == NODE_SCOPE) {
94. Which Branch To Follow? enum node_type { NODE_SCOPE,
95. THIS IS IT!!! default: { COMPILE(ret, "scoped node", node->nd_body); break; }
96. iseq_compile_each
97. iseq_compile_each /** compile each node self: InstructionSequence node: Ruby compiled node poped: This node will be poped */ static int iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
98. > 2300 lines
99. `true` case NODE_TRUE:{ if (!poped) { ADD_INSN1(ret, line, putobject, Qtrue); } break; } AST Node Type Add New LL Item Instruction Name Instruction Arg
100. `p true` $ ruby -e'puts RubyVM::InstructionSequence.new("p true").disasm' == disasm: #<ISeq:<compiled>@<compiled>>================================ 0000 trace 1 ( 1) 0002 putself 0003 putobject true 0005 opt_send_without_block <callinfo!mid:p, argc:1, FCALL| ARGS_SIMPLE>, <callcache> 0008 leave `putobject` Instruction `true` Parameter
101. If Statements then_label = NEW_LABEL(line); else_label = NEW_LABEL(line); end_label = NEW_LABEL(line); compile_branch_condition(iseq, cond_seq, node->nd_cond, then_label, else_label); COMPILE_(then_seq, "then", node->nd_body, poped); COMPILE_(else_seq, "else", node->nd_else, poped); ADD_SEQ(ret, cond_seq); ADD_LABEL(ret, then_label); ADD_SEQ(ret, then_seq); ADD_INSNL(ret, line, jump, end_label); ADD_LABEL(ret, else_label); ADD_SEQ(ret, else_seq); ADD_LABEL(ret, end_label);
102. COMPILE recurses, ADD_* adds a new LL Item
103. Node insn: putself Node insn: putobject arg: true Node insn: opt_send_without_block arg: "p"
104. Why a Linked List?
105. Optimizations
106. rb_iseq_compile_node
107. iseq_setup
108. AST Linked List Optimizations Byte Code
109. iseq_optimize Compile time optimizations
110. Optimization Settings $ ruby -e'p RubyVM::InstructionSequence.compile_option' {:inline_const_cache=>true, :peephole_optimization=>true , :tailcall_optimization=>false, :specialized_instructio n=>true, :operands_unification=>true, :instructions_unif ication=>false, :stack_caching=>false, :trace_instructio n=>true, :frozen_string_literal=>false, :frozen_string_l iteral_debug=>false, :debug_level=>0}
111. Optimization Settings $ ruby -e'p RubyVM::InstructionSequence.compile_option' {:inline_const_cache=>true, :peephole_optimization=>true , :tailcall_optimization=>false, :specialized_instructio n=>true, :operands_unification=>true, :instructions_unif ication=>false, :stack_caching=>false, :trace_instructio n=>true, :frozen_string_literal=>false, :frozen_string_l iteral_debug=>false, :debug_level=>0}
112. Peephole Optimizations: Eliminating Dead Code
113. Dead Code == Useless Instructions
114. Remove Useless Instructions /* * useless jump elimination: * jump LABEL1 * ... * LABEL1: * jump LABEL2 * * => in this case, first jump instruction should jump to * LABEL2 directly */
115. Specialized Instructions
116. For All Your Special Occasions
117. `foo.bar` vs `foo + bar`
118. Regular Method Dispatch (foo.bar) $ ruby -e"puts RubyVM::InstructionSequence.new(\"foo.bar\", nil, nil, 0, :specialized_instruction => false).disasm" == disasm: #<ISeq:<compiled>@<compiled>>================================ 0000 putself 0001 send <callinfo!mid:foo, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>, nil 0005 send <callinfo!mid:bar, argc:0, ARGS_SIMPLE>, <callcache>, nil 0009 leave send
119. Regular Method Dispatch (foo + bar) $ ruby -e"puts RubyVM::InstructionSequence.new(\"foo + bar\", nil, nil, 0, :specialized_instruction => false).disasm" == disasm: #<ISeq:<compiled>@<compiled>>================================ 0000 putself 0001 send <callinfo!mid:foo, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>, nil 0005 putself 0006 send <callinfo!mid:bar, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>, nil 0010 send <callinfo!mid:+, argc:1, ARGS_SIMPLE>, <callcache>, nil 0014 leave send
120. Specialized Instructions $ ruby -e"puts RubyVM::InstructionSequence.new(\"foo + bar\", nil, nil, 0, :specialized_instruction => true).disasm" == disasm: #<ISeq:<compiled>@<compiled>>================================ 0000 putself 0001 opt_send_without_block <callinfo!mid:foo, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache> 0004 putself 0005 opt_send_without_block <callinfo!mid:bar, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache> 0008 opt_plus <callinfo!mid:+, argc:1, ARGS_SIMPLE>, <callcache> 0011 leave send
121. Specialized Instructions do less work
122. Reminder: We haven’t even run any Ruby code yet.
123. Linked Lists:
124. Byte Code
125. iseq_setup
126. iseq_set_sequence
127. Byte Code: A list of integers*. *The integers are addresses
128. This fact will come back to "byte" us.
129. Raw Instructions /** ruby insn object list -> raw instruction sequence */ static int iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor) { LABEL *lobj; INSN *iobj; struct iseq_line_info_entry *line_info_table; unsigned int last_line = 0; LINK_ELEMENT *list; VALUE *generated_iseq; List of actual instructions and parameters
130. Adds instruction to the list generated_iseq[code_index] = insn; … case TS_VALUE: /* VALUE */ { VALUE v = operands[j]; generated_iseq[code_index + 1 + j] = v; /* to mark ruby object */ iseq_add_mark_object(iseq, v); break; } Put the instruction in Add Parameter
131. puts 'foo' $ ruby -e"puts RubyVM::InstructionSequence.new(\"puts 'foo'\").disasm" == disasm: #<ISeq:<compiled>@<compiled>>================================ 0000 trace 1 ( 1) 0002 putself 0003 putstring "foo" 0005 opt_send_without_block <callinfo!mid:puts, argc:1, FCALL|ARGS_SIMPLE>, <callcache> 0008 leave insn "foo"
132. We finally have our byte code!
133. Virtual Machine
134. insns.def
135. Instruction Format @c: category @e: english description @j: japanese description instruction form: DEFINE_INSN instruction_name (instruction_operands, ..) (pop_values, ..) (return value) { .. // insn body } Byte Code Stack
136. putstring Instruction /** @c put @e put string val. string will be copied. @j จࣈྻΛίϐʔͯ͠ελοΫʹϓογϡ͢Δɻ */ DEFINE_INSN putstring (VALUE str) () (VALUE val) { val = rb_str_resurrect(str); }
137. VM Optimizations
138. VM Optimization List $ ruby -e'p RubyVM::OPTS' ["direct threaded code", "operands unification", "inline method cache"]
139. Check vm_core.h
140. Native Execution
141. Code
142. Decode and Dispatch
143. Code Loop Routine Routine
144. Threaded Interpretation
145. Code Loop Routine Routine
146. Code Dispatch Routine Routine Dispatch
147. 1. Our VM is Generated 2. Eliminates the Loop
148. Code Dispatch Routine Routine Dispatch
149. We can do better!
150. What if: The instruction was a function address?
151. Direct Threaded Interpretation
152. Code Dispatch Routine Routine Dispatch
153. Failing at AOT Compiling
154. Byte Code: A list of integers*. *The integers are addresses
155. AHA! If it’s just a list of integers, we should be able to save that list to a file, then load it again.
156. Past Aaron was not too bright.
157. Adds instruction to the list generated_iseq[code_index] = insn; … case TS_VALUE: /* VALUE */ { VALUE v = operands[j]; generated_iseq[code_index + 1 + j] = v; /* to mark ruby object */ iseq_add_mark_object(iseq, v); break; } Add Parameter
158. VALUE is a heap allocated Ruby object.
159. The Pointer Always Changes
160. The Object must be written to disk.
161. END STUFF
162. Practical Applications
163. Tweak Optimizations
164. Understand what your Ruby code is *really* doing.
165. Interpolation vs String#+ # "#{foo}#{bar}" vs foo + bar z = RubyVM::InstructionSequence.new <<-eoruby x = "\#{foo}\#{bar}" eoruby puts z.disasm z = RubyVM::InstructionSequence.new <<-eoruby x = foo + bar eoruby puts z.disasm
166. Browse `iseq_compile_each`
167. Which is faster? TABLE = { 'foo' => 'bar'.freeze, 'bar' => 'baz'.freeze } def table_lookup x TABLE[x] end def case_lookup x case x when 'foo' then 'bar'.freeze when 'bar' then 'baz'.freeze end end
168. Now which is faster? TABLE = { 'foo' => 'bar'.freeze, 'bar' => 'baz'.freeze } def table_lookup x TABLE[x] || 'omg'.freeze end def case_lookup x case x when 'foo' then 'bar'.freeze when 'bar' then 'baz'.freeze when nil then 'omg'.freeze end end
169. Why?
170. REMEMBER THESE:
171. insns.def iseq_compile_each rb_iseq_compile_node
172. Where to learn more
173. yarvarch.ja #title YARVΞʔΩςΫνϟ #set author ೔ຊ Ruby ͷձ ͩ͜͞͞͏͍ͪ - 2005-03-03(Thu) 00:31:12 +0900 ͍Ζ͍Ζͱॻ͖௚͠ ---- * ͜Ε͸ʁ [[YARV: Yet Another RubyVM|http://www.atdot.net/yarv]] ͷ ઃܭϝϞͰ͢ɻ YARV ͸ɺRuby ϓϩάϥϜͷͨΊͷ࣍ͷػೳΛఏڙ͠·͢ɻ - Compiler - VM Generator - VM (Virtual Machine) - Assembler - Dis-Assembler - (experimental) JIT Compiler - (experimental) AOT Compiler ݱࡏͷ YARV ͸ Ruby ΠϯλϓϦλͷ֦ுϥΠϒϥϦͱ࣮ͯ͠૷͍ͯ͠·͢ɻ͜
174. yarvarch.en #title YARV: Yet another RubyVM - Software Architecture maybe writing. * YARV instruction set <%= d %>
176. Thank You!!!