Accelerating Ruby with LLVM

Transcription

1 Accelerating Ruby with LLVM Evan Phoenix Oct 2, 2009

2 RUBY

3 RUBY Strongly, dynamically typed

4 RUBY Unified Model

5 RUBY Everything is an object

6 RUBY 3.class # => Fixnum

7 RUBY Every code context is equal

8 RUBY Every context is a method

9 RUBY Garbage Collected

10 RUBY A lot of syntax

11 RUBY Strongly, dynamically typed Unified model Everything is an object 3.class Every code context is equal Every context is a method Garbage collected A lot of syntax

12 Rubinius

13 Rubinius Started in 2006

14 Rubinius Build a ruby environment for fun

15 Rubinius Unlike most scripting languages, write as much in ruby as possible

16 Rubinius Core functionality of perl/python/ruby in C, NOT in their respective language.

17 Rubinius C => ruby => C => ruby

18 Rubinius Language boundaries suck

19 Rubinius Started in 2006 Built for fun Turtles all the way down

20 Evolution

21 Evolution 100% ruby prototype running on 1.8

22 Evolution Hand translated VM to C

23 Evolution Rewrote VM in C++

24 Evolution Switch away from stackless

25 Evolution Experimented with handwritten assembler for x86

26 Evolution Switch to LLVM for JIT

27 Evolution 100% ruby prototype Hand translated VM to C Rewrote VM in C++ Switch away from stackless Experiment with assembler Switch to LLVM for JIT

28 Features

29 Features Bytecode VM

30 Features Simple interface to native code

31 Features Accurate, generational garbage collector

32 Features Integrated FFI API

33 Features Bytecode VM Interface to native code Generational GC Integrated FFI

34 Benchmarks

35 def foo() ary = [] 100.times { i ary << i } end 300,000 times

36 Seconds rbx rbx jit rbx jit +blocks

37 def foo() hsh = {} 100.times { i hsh[i] = 0 } end 100,000 times

38 Seconds rbx rbx jit rbx jit +blocks

39 def foo() hsh = { 47 => true } 100.times { i hsh[i] } end 100,000 times

40 Seconds rbx rbx jit rbx jit +blocks

41 Early LLVM Usage

42 Early LLVM Usage Compiled all methods up front

43 Early LLVM Usage Simple opcode-to-function translation with inlining

44 Early LLVM Usage Startup went from 0.3s to 80s

45 Early LLVM Usage Compiled all methods upfront Simple opcode-to-function translation Startup from 0.3s to 80s

46 True JIT

47 True JIT JIT Goals

48 True JIT JIT Goals Choose methods that benefit the most

49 True JIT JIT Goals Compiling has minimum impact on performance

50 True JIT JIT Goals Ability to make intelligent frontend decisions

51 Choosing Methods

52 Choosing Methods Simple call counters

53 Choosing Methods When counter trips, the fun starts

54 Choosing Methods Room for improvement

55 Choosing Methods Room for improvement Increment counters in loops

56 Choosing Methods Room for improvement Weigh different invocations differently

57 Choosing Methods Simple counters Trip the counters, do it Room for improvement Increment in loops Weigh invocations

58 Which Method?

59 Which Method? Leaf methods trip quickly

60 Which Methods? Leaf methods trip quickly Consider the whole callstack

61 Which Methods? Leaf methods trip quickly Pick a parent expecting inlining

62 Which Method? Leaf methods trip Consider the callstack Find a parent

63 Minimal Impact

64 Minimal Impact After the counters trip

65 Minimal Impact Queue the method

66 Minimal Impact Background thread drains queue

67 Minimal Impact Frontend, passes, codegen in background

68 Minimal Impact Install JIT d function

69 Minimal Impact Install JIT d function Requires GC interaction

70 Minimal Impact Trip the counters Queue the method Compile in background Install function pointer

71 Good Decisions

72 Good Decisions Naive translation yields fixed improvement

73 Good Decisions Performance shifts to method dispatch

74 Good Decisions Improve optimization horizon

75 Good Decisions Inline using type feedback

76 Good Decisions Naive translation sucks Inline using type feedback Performance in dispatch Improve optimizations

77 Type Feedback

78 Type Feedback Frontend translates to IR

79 Type Feedback Read InlineCache information

80 Type Feedback InlineCaches contain profiling info

81 Type Feedback Use profiling to drive inlining!

82 Type Feedback Frontend generates IR Reads InlineCaches InlineCaches have profiling Use profiling to drive inlining!

83 Inlining

84 Inlining Profiling info shows a dominant class

85 2 1% 1 class 98%

86 Inlining Lookup method in compiler

87 Inlining For native functions, emit direct call

88 Inlining For FFI, inline conversions and call

89 Inlining Find dominant class Lookup method Emit direct calls if possible

90 Inlining Ruby

91 Inlining Ruby Policy decides on inlining

92 Inlining Ruby Drive sub-frontend at call site

93 Inlining Ruby All inlining occurs in the frontend

94 Inlining Ruby Generated IR preserves runtime data

95 Inlining Ruby Generated IR preserves runtime data GC roots, backtraces, etc

96 Inlining Ruby No AST between bytecode and IR

97 Inlining Ruby No AST between bytecode and IR Fast, but limits the ability to generate better IR

98 Inlining Ruby Policy decides Drive sub-frontend Preserve runtime data Generates fast, ugly IR

99 LLVM

100 LLVM IR uses operand stack

101 LLVM IR uses operand stack Highlevel data flow not in SSA

102 LLVM IR uses operand stack Passes eliminate redundencies

103 LLVM IR uses operand stack Makes GC stack marking easy

104 LLVM IR uses operand stack nocapture improves propagation

105 LLVM Exceptions via sentinal value

106 LLVM Exceptions via sentinal value Nested handlers use branches for control

107 LLVM Exceptions via sentinal value Inlining exposes redundant checks

108 LLVM Inline guards

109 LLVM Inline guards Simple type guards

110 if(obj->class->class_id == <integer constant>) {

111 LLVM Inline guards Custom AA pass for guard elimination

112 LLVM Inline guards Teach pointstoconstantmemory about...

113 if(obj->class->class_id == <integer constant>) {

114 if(obj->class->class_id == <integer constant>) {

115 LLVM Maximizing constant propagation

116 LLVM Maximizing constant propagation Type failures shouldn t contribute values

117 if(obj->class->class_id == 0x33) { val = 0x7; } else { val = send_msg(state, obj,...); }

118 if(obj->class->class_id == 0x33) { val = 0x7; } else { return uncommon(state); }

119 LLVM Maximizing constant propagation Makes JIT similar to tracing

120 LLVM Use overflow intrinsics

121 LLVM Use overflow intrinsics Custom pass to fold constants arguments

122 LLVM AA knowledge for tagged pointers

123 LLVM AA knowledge of tagged pointers 0x5 is 2 as a tagged pointer

124 LLVM Not in SSA form Simplistic exceptions Inlining guards Maximize constants Use overflow Tagged pointer AA

125 Issues

126 Issues How to link with LLVM?

127 Issues How to link with LLVM? An important SCM issue

128 Issues Ugly, confusing IR from frontend

129 Issues instcombine confuses basicaa

130 Issues Operand stack confuses AA

131 Issues Inability to communicate semantics

132 Object* new_object(state)

133 Returned pointer aliases nothing Only modifies state If return value is unused, remove the call Semi-pure?

134 Issues Ugly IR Linking with LLVM AA confusion Highlevel semantics

135 Thanks!