JIT stands for Just-In-Time compiler. JIT converts repetitive code into bytecodewhich can then be sent to the processor directly, hence, saving time by notcompiling 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 MethodBased 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 mainlyon performance. In addition to performance, it also aims for the followingthings:

1. Portability
2. Stability
3. Security

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

ruby --help

You will see following options.

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

Vladimir Makarov proposed improving performance by replacing VM instructionswith RTL(Register Transfer Language) and introducing the Method based JITcompiler.

Vladimir explained MJIT architecture in hisRubyKaigi 2017 conference keynote.

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

Let's take a look at how MJIT works.

# mjit.rbrequire 'benchmark'puts Benchmark.measure {def test_whilestart_time = Time.nowi = 0    while i < 4      i += 1    end    i    puts Time.now - start_timeend4.times { test_while }}

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

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

Time taken is 4.0e-06Time taken is 0.0Time taken is 0.0Time taken is 0.00.000082 0.000032 0.000114 ( 0.000105)Successful MJIT finish

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

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

require 'benchmark'puts Benchmark.measure {def test_whilestart_time = Time.nowi = 0    while i < 4_00_00_000      i += 1    end    puts "Time taken is #{Time.now - start_time}"end10.times { test_while }}

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

Time taken is 0.457916Time taken is 0.455921Time taken is 0.454672Time taken is 0.452823JIT success (72.5ms): block (2 levels) in <main>@mjit.rb:15 -> /var/folders/v6/\_6sh53vn5gl3lct18w533gr80000gn/T//\_ruby_mjit_p66220u0.cJIT success (140.9ms): test_while@mjit.rb:4 -> /var/folders/v6/\_6sh53vn5gl3lct18w533gr80000gn/T//\_ruby_mjit_p66220u1.cJIT compaction (23.0ms): Compacted 2 methods -> /var/folders/v6/\_6sh53vn5gl3lct18w533gr80000gn/T//\_ruby_mjit_p66220u2.bundleTime taken is 0.463703Time taken is 0.102852Time taken is 0.103335Time taken is 0.103299Time taken is 0.103252Time taken is 0.1032612.797843 0.005357 3.141944 ( 2.801391)Successful MJIT finish

Here's what's happening. Method ran 4 times and on the 5th call it found it isrunning same code again. So MJIT started a separate thread to convert the codeinto RTL instructions, which created a shared object library. Next, threads tookthat shared code and executed directly. As we passed option --jit-verbose=1 wecan 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 binaryinstructions 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. Wecan start the rails server with the JIT option, as shown below.

RUBYOPT="--jit" bundle exec rails s

Now, we can start testing the performance on servers. We found that Ruby 2.6 isfaster than Ruby 2.5, but enabling JIT in Ruby 2.6 does not add more value tothe 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

(1..10).cover?(5)=> true

Range#cover? returns false if the object passed as an argument isnon-comparable or is not in the range.

Before Ruby 2.6, Range#cover? used to return false if a Range object is passedas an argument.

>> (1..10).cover?(2..5)=> false

Ruby 2.6

In Ruby 2.6 Range#cover? can accept a Range object as an argument. It returnstrue if the argument Range is equal to or a subset of the Range.

(1..100).cover?(10..20)=> true(1..10).cover?(2..5)=> true(5..).cover?(4..)=> false("a".."d").cover?("x".."z")=> false

Here is relevantcommitand discussion for this change.

As of now, RubyVM::AST supports two methods: parse and parse_file.

parse method takes a string as a parameter and returns the root node of thetree in the form of the object, RubyVM::AST::Node (Link is not available).

parse_file method takes the file name as a parameter and returns the root nodeof the tree in the form of the object,RubyVM::AST::Node.

Ruby 2.6.0-preview2

irb> RubyVM::AST.parse("(1..100).select { |num| num % 5 == 0 }")=> #<RubyVM::AST::Node(NODE_SCOPE(0) 1:0, 1:38): >irb> RubyVM::AST.parse_file("/Users/amit/app.rb")=> #<RubyVM::AST::Node(NODE_SCOPE(0) 1:0, 1:38): >

RubyVM::AST::Nodehas seven public instance methods - children, first_column, first_lineno,inspect, last_column, last_lineno and type.

Ruby 2.6.0-preview2

irb> ast_node = RubyVM::AST.parse("(1..100).select { |num| num % 5 == 0 }")=> #<RubyVM::AST::Node(NODE_SCOPE(0) 1:0, 1:38): >irb> ast_node.children=> [nil, #<RubyVM::AST::Node(NODE_ITER(9) 1:0, 1:38): >]irb> ast_node.first_column=> 0irb> ast_node.first_lineno=> 1irb> ast_node.inspect=> "#<RubyVM::AST::Node(NODE_SCOPE(0) 1:0, 1:38): >"irb> ast_node.last_column=> 38irb> ast_node.last_lineno=> 1irb> ast_node.type=> "NODE_SCOPE"

This module will majorly help in building a static code analyzer and formatter.

Let's take an example in which we have to select/filter all numbers which aredivisible by 5 from a range.

Ruby 2.5

irb> (1..100).select { |num| num % 5 == 0 }=> [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]irb> (1..100).filter { |num| num % 5 == 0 }=> Traceback (most recent call last):2: from /Users/amit/.rvm/rubies/ruby-2.5.1/bin/irb:11:in `<main>' 1: from (irb):2 NoMethodError (undefined method`filter' for 1..100:Range)

Ruby 2.6.0-preview2

irb> (1..100).select { |num| num % 5 == 0 }=> [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]irb> (1..100).filter { |num| num % 5 == 0 }=> [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]

Also note, along with Enumerable#filter, Enumerable#filter!,Enumerable#select! was also added as an alias.

Here is the relevant commitand discussion.

Below code will raise class/module name must be CONSTANT exception.

  class   end

We can use above non-ASCII character as a method name or variable name though.

Below code will run without any exception

  class NonAsciiMethodAndVariable    def        = "BigBinary"    end  end

"" is treated as a variable name in above example, even though firstletter() is a capital non-ASCII character.

Ruby 2.6

Ruby 2.6 relaxes above mentioned limitation. We can now define constants inlanguages other than English. Languages having capital letters like Russian andGreek can be used to define constant name.

Below code will run without exception in any Ruby 2.6.

  class   end

As capital non-Ascii characters are now treated as constant, below code willraise a warning in Ruby 2.6.

  irb(main):001:0>  = "BigBinary"  => "BigBinary"  irb(main):002:0>  = "BigBinary"  (irb):2: warning: already initialized constant   (irb):1: warning: previous definition of  was here

Above code will run without any warnings on Ruby versions prior to 2.6

Here is relevant commit anddiscussion for this change.

Similarly, write_timeout attribute and write_timeout= method is added toNet::BufferedIO class.

If any chunk of response is not written within number of seconds provided towrite_timeout, Net::WriteTimeoutexception is raised. Net::WriteTimeout exception is not raised on Windowssystems.

Example

# server.rbrequire 'socket'server = TCPServer.new('localhost', 2345)loop dosocket = server.acceptend

Ruby 2.5.1

# client.rbrequire 'net/http'connection = Net::HTTP.new('localhost', 2345)connection.open_timeout = 1connection.read_timeout = 3connection.startpost = Net::HTTP::Post.new('/')body = (('a' _ 1023) + "\n") _ 5_000post.body = bodyputs "Sending #{body.bytesize} bytes"connection.request(post)

Output

\$ RBENV_VERSION=2.5.1 ruby client.rbSending 5120000 bytes

Ruby 2.5.1 processes request endlessly unless above program is interrupted.

Ruby 2.6.0-dev

Add write_timeout attribute to Net::HTTP instance in client.rb program.

# client.rbrequire 'net/http'connection = Net::HTTP.new('localhost', 2345)connection.open_timeout = 1connection.read_timeout = 3# set write_timeout to 10 secondsconnection.write_timeout = 10connection.startpost = Net::HTTP::Post.new('/')body = (('a' _ 1023) + "\n") _ 5_000post.body = bodyputs "Sending #{body.bytesize} bytes"connection.request(post)

Output

\$ RBENV_VERSION=2.6.0-dev ruby client.rbSending 5120000 bytesTraceback (most recent call last):13: `from client.rb:17:in `<main>`` 12: `from /net/http.rb:1479:in `request``11: `from /net/http.rb:1506:in `transport_request`` 10: `from /net/http.rb:1506:in `catch``9: `from /net/http.rb:1507:in `block in transport_request`` 8: `from /net/http/generic_request.rb:123:in `exec``7: `from /net/http/generic_request.rb:189:in `send_request_with_body`` 6: `from /net/protocol.rb:221:in `write``5: `from /net/protocol.rb:239:in `writing`` 4: `from /net/protocol.rb:222:in `block in write``3: `from /net/protocol.rb:249:in `write0`` 2: `from /net/protocol.rb:249:in `each_with_index``1: `from /net/protocol.rb:249:in `each`` `/net/protocol.rb:270:in `block in write0`: Net::WriteTimeout (Net::WriteTimeout)`

In Ruby 2.6.0, above program is terminated raising Net::WriteTimeout exceptionafter 10 seconds (value set to write_timeout attribute).

Here is relevant commit anddiscussion for this change.

In Ruby 2.6, same methods are added as instance methods on Dir class.Dir#children (Link is not available) returns array of all the filenames except. and .. in the directory. Dir#each_child (Link is not available) yields allthe filenames and operates on it.

Let's have a look at examples to understand it better.

Dir#children

directory = Dir.new('/Users/tejaswinichile/workspace')directory.children=> ["panda.png", "apple.png", "banana.png", "camera.jpg"]

Dir#each_child iterates and calls block for each file entry in the givendirectory. It uses filename as a parameter to the block.

Dir#each_child

directory = Dir.new('/Users/tejaswinichile/workspace')directory.each_child { |filename| puts "Currently reading: #{filename}"}Currently reading: panda.pngCurrently reading: apple.pngCurrently reading: banana.pngCurrently reading: camera.jpg=> #<Dir:/Users/tejaswinichile/Desktop>

If we don't pass any block to each_child, it returns enumerator instead.

directory = Dir.new('/Users/tejaswinichile/workspace')directory.each_child=> #<Enumerator: #<Dir:/Users/tejaswinichile/Desktop>:each_child>

Here is relevantcommitand discussion for this change.

> > "1one".to_i> > => 1> > Integer("1one")> > ArgumentError: invalid value for Integer(): "1one"    from (irb):2:in `Integer'    from (irb):2    from /Users/prathamesh/.rbenv/versions/2.4.0/bin/irb:11:in `<main>'> >

The to_i method tries to convert the given input to integer as much aspossible whereas the Integer method throws an ArgumentError if it can'tcovert the input to integer. The Integer and Float methods parse morestrictly compared to to_i and to_f respectively.

Some times, we might need the strictness of Integer and Float but ability tonot raise an exception every time the input can't be parsed.

Before Ruby 2.6 it was possible to achieve it in following way.

> > Integer("msg") rescue nil> >

In Ruby 2.6, theInteger and Float methods accept a keyword argument exceptionwhich can be either true or false. If it is false then no exception israised if the input can't be parsed and nil is returned.

> > Float("foo", exception: false)> > => nil> > Integer("foo", exception: false)> > => nil> >

This is also faster than rescuing the exception and returning nil.

> > Benchmark.ips do |x|> > ?> x.report("rescue") {> > ?> Integer('foo') rescue nil> > }> > x.report("kwarg") {> > ?> Integer('foo', exception: false)> > }> > x.compare!> > end> > Warming up --------------------------------------              rescue    41.896k i/100ms               kwarg    81.459k i/100msCalculating -------------------------------------rescue 488.006k ( 4.5%) i/s - 2.472M in 5.076848skwarg 1.024M (11.8%) i/s - 5.050M in 5.024937sComparison:kwarg: 1023555.3 i/srescue: 488006.0 i/s - 2.10x slower

As we can see, rescuing the exception is twice slower than using the new keywordargument. We can still use the older technique if we want to return a differentvalue from nil.

> > Integer('foo') rescue 42> > => 42> >

By default, the keyword argument exception is set to true for backwardcompatibility.

The Chinese version of this blog is availablehere.

binding.eval('[__FILE__, __LINE__]')=> ["/Users/taha/blog/app/controllers/application_controller", 2]

Ruby 2.6 adds more readable method Binding#source_location (Link is notavailable) to achieve similar result.

binding.source_location=> ["/Users/taha/blog/app/controllers/application_controller", 2]

Here is relevant commit anddiscussion for this change.

The Chinese version of this blog is availablehere.

In Ruby 2.6, a block can be passed to String#split (Link is not available) whichyields each split string and operates on it. This avoids creating an array andthus is memory efficient.

We will add method is_fruit? to understand how to use split with a block.

def is_fruit?(value)%w(apple mango banana watermelon grapes guava lychee).include?(value)end

Input is a comma separated string with vegetables and fruits names. Goal is tofetch names of fruits from input string and store it in an array.

String#split

input_str = "apple, mango, potato, banana, cabbage, watermelon, grapes"splitted_values = input_str.split(", ")=> ["apple", "mango", "potato", "banana", "cabbage", "watermelon", "grapes"]fruits = splitted_values.select { |value| is_fruit?(value) }=> ["apple", "mango", "banana", "watermelon", "grapes"]

Using split an intermediate array is created which contains both fruits andvegetables names.

String#split with a block

fruits = []input_str = "apple, mango, potato, banana, cabbage, watermelon, grapes"input_str.split(", ") { |value| fruits << value if is_fruit?(value) }=> "apple, mango, potato, banana, cabbage, watermelon, grapes"fruits=> ["apple", "mango", "banana", "watermelon", "grapes"]

When a block is passed to split, it returns the string on which split wascalled and does not create an array. String#split yields block on each splitstring, which in our case was to push fruit names in a separate array.

Update

Benchmark

We created a large random string to benchmark performance of split andsplit with block

require 'securerandom'test_string = ''100_000.times.each dotest_string += SecureRandom.alphanumeric(10)test_string += ' 'end

require 'benchmark'Benchmark.bmbm do |bench|bench.report('split') doarr = test_string.split(' ')str_starts_with_a = arr.select { |str| str.start_with?('a') }endbench.report('split with block') dostr_starts_with_a = []test_string.split(' ') { |str| str_starts_with_a << str if str.start_with?('a') }endend

Results

Rehearsal ----------------------------------------------------split              0.023764   0.000911   0.024675 (  0.024686)split with block   0.012892   0.000553   0.013445 (  0.013486)------------------------------------------- total: 0.038120sec                       user     system      total        realsplit              0.024107   0.000487   0.024594 (  0.024622)split with block   0.010613   0.000334   0.010947 (  0.010991)

We did another iteration of benchmarking usingbenchmark/ips.

require 'benchmark/ips'Benchmark.ips do |bench|bench.report('split') dosplitted_arr = test_string.split(' ')str_starts_with_a = splitted_arr.select { |str| str.start_with?('a') }endbench.report('split with block') dostr_starts_with_a = []test_string.split(' ') { |str| str_starts_with_a << str if str.start_with?('a') }endbench.compare!end

Results

Warming up --------------------------------------               split     4.000  i/100ms    split with block    10.000  i/100msCalculating -------------------------------------               split     46.906  ( 2.1%) i/s -    236.000  in   5.033343s    split with block    107.301  ( 1.9%) i/s -    540.000  in   5.033614sComparison:    split with block:      107.3 i/s               split:       46.9 i/s - 2.29x  slower

This benchmark shows that split with block is about 2 times faster thansplit.

Here is relevantcommitand discussion for this change.

The Chinese version of this blog is availablehere.

If we use else without rescue inside begin..end block in Ruby 2.5, itgives a warning.

irb(main):001:0> beginirb(main):002:1> puts "Inside begin block"irb(main):003:1> elseirb(main):004:1> puts "Inside else block"irb(main):005:1> end(irb):5: warning: else without rescue is useless

This warning is present as code inside else block will never get executed

Ruby 2.6

In Ruby 2.6 it will raise an exception if we use else without rescue inbegin..end block. Thiscommitchanged warning into exception in Ruby 2.6. Changes made in the commit areexperimental.

irb(main):001:0> beginirb(main):002:1> puts "Inside begin block"irb(main):003:1> elseirb(main):004:1> puts "Inside else block"irb(main):005:1> endTraceback (most recent call last):1: from /usr/local/bin/irb:11:in `<main>'SyntaxError ((irb):3: else without rescue is useless)

The Chinese version of this blog is availablehere.

Ruby 2.5.0

irb> (1..Float::INFINITY).each do |n|irb\* # logic goes hereirb> end

OR

irb> 1.step.each do |n|irb\* # logic goes hereirb> end

Ruby 2.6.0

Ruby 2.6 makes infinite loop more readable by changing mandatory second argumentin range to optional. Internally, Ruby changes second argument to nil ifsecond argument is not provided. So, both (0..) and (0..nil) are same inRuby 2.6.

Using endless loop in Ruby 2.6

irb> (0..).each do |n|irb\* # logic goes hereirb> end

irb> (0..nil).size=> Infinityirb> (0..).size=> Infinity

In Ruby 2.5, nil is not an acceptable argument and (0..nil) would throwArgumentError.

irb> (0..nil)ArgumentError (bad value for range)

Here is the relevantcommitand discussion for this change.

The Chinese version of this blog is availablehere.

Let's suppose we need to run migrations using rake db:migrate in a Railsproject setup script. We can use the Kernel#system method.

irb> system('rake db:migrate')

Ruby 2.5.0

Executing system returns true or false. Another feature of system isthat it eats up the exceptions.

Let's suppose our migrations can run successfully. In this case the systemcommand for running migrations will return true.

irb> system('rake db:migrate') => true

Let's suppose we have a migration that is trying to add a column to a tablewhich does not exist. In this case, the system command for running migrationswill return false.

irb> system('rake db:migrate')== 20180311211836 AddFirstNameToAdmins: migrating =============================-- add_column(:admins, :first_name, :string)rake aborted!StandardError: An error has occurred, this and all later migrations canceled:PG::UndefinedTable: ERROR:  relation "admins" does not exist: ALTER TABLE "admins" ADD "first_name" character varying...Tasks: TOP => db:migrate(See full trace by running task with --trace) => false

As we can see, even when there is a failure in executing system commands, thereturn value is false. Ruby does not raise an exception in those cases.

However, we can use raise explicitly to raise an exception and halt the setupscript execution.

irb> system('rake db:migrate') || raise('Failed to run migrations')== 20180311211836 AddFirstNameToAdmins: migrating =============================-- add_column(:admins, :first_name, :string)rake aborted!StandardError: An error has occurred, this and all later migrations canceled:PG::UndefinedTable: ERROR:  relation "admins" does not exist: ALTER TABLE "admins" ADD "first_name" character varying...Tasks: TOP => db:migrate(See full trace by running task with --trace)Traceback (most recent call last):        2: from /Users/amit/.rvm/rubies/ruby-2.5.0/bin/irb:11:in `<main>'        1: from (irb):4RuntimeError (Failed to run migrations)

Ruby 2.6.0-preview1

Ruby 2.6 make our lives easier by providing an option exception: true so thatwe do not need to use raise explicitly to halt script execution.

irb> system('rake db:migrate', exception: true)== 20180311211836 AddFirstNameToAdmins: migrating =============================-- add_column(:admins, :first_name, :string)rake aborted!StandardError: An error has occurred, this and all later migrations canceled:PG::UndefinedTable: ERROR:  relation "admins" does not exist: ALTER TABLE "admins" ADD "first_name" character varying...Tasks: TOP => db:migrate(See full trace by running task with --trace)Traceback (most recent call last):        3: from /Users/amit/.rvm/rubies/ruby-2.6.0-preview1/bin/irb:11:in `<main>'        2: from (irb):2        1: from (irb):2:in `system'RuntimeError (Command failed with exit 1: rake)

Ruby 2.6 works the same way as previous Ruby versions when used without theexception option or used with exception set as false.

irb> system('rake db:migrate', exception: false)== 20180311211836 AddFirstNameToAdmins: migrating =============================-- add_column(:admins, :first_name, :string)rake aborted!StandardError: An error has occurred, this and all later migrations canceled:PG::UndefinedTable: ERROR:  relation "admins" does not exist: ALTER TABLE "admins" ADD "first_name" character varying...Tasks: TOP => db:migrate(See full trace by running task with --trace) => false

Here is the relevant commitand discussion for this change.

system is not the only way to execute scripts like these. We wrotea blog6 years ago which discusses the differences between running commands usingbacktick, exec, sh, popen3, popen2e and Process.spawn.

The Chinese version of this blog is availablehere.