MJIT Support in Ruby 2.6

What is JIT?

JIT stands for Just-In-Time compiler. JIT converts repetitive code into bytecode which can then be sent to the processor directly, hence, saving time by not compiling the same piece of code over and over.

Ruby 2.6

MJIT is introduced in Ruby 2.6. It is most commonly known as MRI JIT or Method Based JIT.

It is a part of the Ruby 3x3 project started by Matz. The name "Ruby 3x3" signifies Ruby 3.0 will be 3 times faster than Ruby 2.0 and it will focus mainly on performance. In addition to performance, it also aims for the following things:

1. Portability
2. Stability
3. Security

MJIT is still in development, therefore, MJIT is optional in Ruby 2.6. If you are running Ruby 2.6, then you can execute the following command.

1ruby --help
Copy

You will see following options.

1--Jit-wait # Wait program execution until code compiles.
2--jit-verbose=num # Level information MJIT compiler prints for Ruby program.
3--jit-min-calls=num # Minimum count in loops for which MJIT should work.
4--jit-max-cache
5--jit-save-temps # Save compiled library to the file.
Copy

Vladimir Makarov proposed improving performance by replacing VM instructions with RTL(Register Transfer Language) and introducing the Method based JIT compiler.

Vladimir explained MJIT architecture in his RubyKaigi 2017 conference keynote.

Ruby's compiler converts the code to YARV(Yet Another Ruby VM) instructions and then these instructions are run by the Ruby Virtual Machine. Code that is executed too often is converted to RTL instructions, which runs faster.

Let's take a look at how MJIT works.

1
2# mjit.rb
3
4require 'benchmark'
5
6puts Benchmark.measure {
7def test_while
8start_time = Time.now
9i = 0
10
11    while i < 4
12      i += 1
13    end
14
15    i
16    puts Time.now - start_time
17
18end
19
204.times { test_while }
21}
Copy

Let's run this code with MJIT options and check what we got.

1ruby --jit --jit-verbose=1 --jit-wait --disable-gems mjit.rb
Copy

1Time taken is 4.0e-06
2Time taken is 0.0
3Time taken is 0.0
4Time taken is 0.0
50.000082 0.000032 0.000114 ( 0.000105)
6Successful MJIT finish
Copy

Nothing interesting right? And why is that? because we are iterating the loop for 4 times and default value for MJIT to work is 5. We can always decide after how many calls MJIT should work by providing --jit-min-calls=#number option.

Let's tweak the program a bit so MJIT gets to work.

1require 'benchmark'
2
3puts Benchmark.measure {
4def test_while
5start_time = Time.now
6i = 0
7
8    while i < 4_00_00_000
9      i += 1
10    end
11
12    puts "Time taken is #{Time.now - start_time}"
13
14end
15
1610.times { test_while }
17}
Copy

After running the above code we can see some work done by MJIT.

1Time taken is 0.457916
2Time taken is 0.455921
3Time taken is 0.454672
4Time taken is 0.452823
5JIT success (72.5ms): block (2 levels) in <main>@mjit.rb:15 -> /var/folders/v6/\_6sh53vn5gl3lct18w533gr80000gn/T//\_ruby_mjit_p66220u0.c
6JIT success (140.9ms): [email protected]:4 -> /var/folders/v6/\_6sh53vn5gl3lct18w533gr80000gn/T//\_ruby_mjit_p66220u1.c
7JIT compaction (23.0ms): Compacted 2 methods -> /var/folders/v6/\_6sh53vn5gl3lct18w533gr80000gn/T//\_ruby_mjit_p66220u2.bundle
8Time taken is 0.463703
9Time taken is 0.102852
10Time taken is 0.103335
11Time taken is 0.103299
12Time taken is 0.103252
13Time taken is 0.103261
142.797843 0.005357 3.141944 ( 2.801391)
15Successful MJIT finish
Copy

Here's what's happening. Method ran 4 times and on the 5th call it found it is running same code again. So MJIT started a separate thread to convert the code into RTL instructions, which created a shared object library. Next, threads took that shared code and executed directly. As we passed option --jit-verbose=1 we can see what MJIT did.

What we are seeing in output is the following:

1. Time taken to compile.
2. What block of code is compiled by JIT.
3. Location of compiled code.

We can open the file and see how MJIT converted the piece of code to binary instructions but for that we need to pass another option which is --jit-save-temps and then just inspect those files.

After compiling the code to RTL instructions, take a look at the execution time. It dropped down to 0.10 ms from 0.46 ms. That's a neat speed bump.

Here is a comparison across some of the Ruby versions for some basic operations.


Rails comparison on Ruby 2.5, Ruby 2.6 and Ruby 2.6 with JIT

Create a rails application with different Ruby versions and start a server. We can start the rails server with the JIT option, as shown below.

1RUBYOPT="--jit" bundle exec rails s
Copy

Now, we can start testing the performance on servers. We found that Ruby 2.6 is faster than Ruby 2.5, but enabling JIT in Ruby 2.6 does not add more value to the Rails application.

MJIT status and future directions

• It is in an early development stage.
• Does not work on windows.
• Needs more time to mature.
• Needs more optimisations.
• MJIT can use GCC or LLVM in the future C Compilers.

Further reading

1. Ruby 3x3 Performance Goal
2. The method JIT compiler for Ruby2.6
3. Vladimir Makarov's Ruby Edition