Sometimes you might need a way to measure the time it takes your code to execute.
This works...
Throw in a good old Time.now
and then subtract the time start time from the new Time.now
after the code executes.
# let's see how long it takes the Ruby interpreter
# to string together 5 million integers.
def string_together_ten_million_integers
start_time = Time.now
array = []
10_000_000.times { |num| array << num }
array.join
end_time = Time.now
puts "Took #{end_time - start_time} seconds to execute"
end
For me, this takes around 1.7 seconds on average. Is yours similar?
Now, we can change things up and see if there are faster solutions. For instance, what if you convert the integers to String before you join?
# convert the integers to String before the join
array = []
10_000_000.times { |num| array << num.to_s }
array.join
Hmm... 🤔 now it's more like 1.3 seconds. Making that change seemed to shave off half a second.
But wouldn't it make more sense to just instantiate a mutable String to push integers into? Then, there is no need to join.
# instantiate a String instead of an array
string = ""
10_000_000.times { |num| string << num.to_s }
Which one is the fastest for you?
It's getting harder to keep track of all our results! Wouldn't it be great to see these methods profiled all at once and see the results neatly printed together?
That's where the Ruby Benchmark
class comes in.
This is better...
Benchmark is part of the Ruby standard library, meaning that it's readily available to require and use. Just type require 'benchmark'
at the top of your file or any time during your IRB session.
You can also type irb -r benchmark
when you start up your IRB session.
Like every module in the Ruby StdLib you can find the documentation at ruby-doc.org.
The simplest way to use Benchmark is to send it the class method ::measure
and provide a block of code as the argument.
Benchmark.measure("label") do
# block of code to measure
end
Try inserting some of the above methods into the Benchmark block and see what the resulting times are.
You're going to see the return value as a Benchmark::Tms
class with the following attributes:
- cstime - children system CPU time
- cutime - children user CPU time
- stime - system CPU time
- utime - user CPU time
- total - cstime + cutime + stime + utime
- real - total elapsed time
Now for a little explanation of these terms. The user time is how long it actually takes for your code to execute. The system time is the underlying system underneath your code to do what it needs to do (your computer's kernel, etc.). The total time is the addition of the system and the user times.
So what is the real time? That's adding in user input, network connections, etc. If you only care about the actual wall clock time from start to finish, just look at the real time.
The children system and user times would be for any other methods called within your block. These would be child processes.
Although using Benchmark::measure
is a good way to measure the run time for one block of code, there is a way to measure different blocks side by side.
The best way...
Instead of ::measure
, let's use the ::bm
method. This method allows you to generate reports of multiple code blocks. Perfect! Let's use this with our three methods above.
By the way, in Ruby we use '#' before instance method names and '::' before class method names when we refer to them. Since we never have to call
Benchmark.new
, we use the class methods only.
require 'benchmark'
Benchmark.bm do |x|
x.report("array/join") do
array = []
10_000_000.times { |num| array << num }
array.join
end
x.report("array/to_s/join") do
array = []
10_000_000.times { |num| array << num.to_s }
array.join
end
x.report("string/to_s") do
string = ""
10_000_000.times { |num| string << num.to_s }
end
end
Did the results that printed to your console align correctly? With longer labels we need to adjust the label_width
of the results. It's actually the first argument to the ::bm
method, so try Benchmark.bm(20) do |x|
to spread out the results.
These are the results on my machine:
user system total real
array/join 1.551520 0.168228 1.719748 ( 1.789678)
array/to_s/join 1.209965 0.122323 1.332288 ( 1.373220)
string/to_s 0.893824 0.047670 0.941494 ( 0.949304)
Hopefully you are feeling empowered to profile your Ruby code with the Benchmark utility!
Advanced additional content
One way to challenge your understanding of the Ruby Standard Library is to peruse through the source code. You'll find that it's not as intimidating as you might think.
Don't feel pressure to understand it all at first glance. Feel encouraged that you understand any of it and with practice your understanding will grow and grow!
Where can you find it? I use RVM (Ruby Version Manager) to manage and install my rubies and gems. So for me, I have a .rvm directory in my home directory. This is where the Standard Library is housed.
For me its ~/.rvm/rubies/ruby-3.0.0/lib/ruby/3.0.0
.
From there you can open open up the benchmark.rb file and see the source code. It's a small module (written over 20 years ago!) of just over 500 lines with much of that taken up with documentation.
Notes
I first noted the different parameters the various methods received. This helped me to understand how I could use the methods.
I wanted my reports to have a longer width. I saw that the Report
class was instantiated with a width
attribute from the ::benchmark
method which is called from the ::bm
method. That's how I learned I could call ::bm
with '20' as the argument to spread out the report.
Another interesting note is that the magic of Benchmark really happens in the ::measure
method on line 291.
def measure(label = "") # :yield:
t0, r0 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
yield
t1, r1 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
Benchmark::Tms.new(t1.utime - t0.utime,
t1.stime - t0.stime,
t1.cutime - t0.cutime,
t1.cstime - t0.cstime,
r1 - r0,
label)
end
Just like we were inserting Time.now
in our original code, that's really all Benchmark does. Only, it uses a more sophisticated approach, Process.times
and Process.clock_gettime()
. Then it yields the block of code supplied and calls the same Process methods again and does the subtraction. This almost exactly what we were doing.
Apparently it isn't magic, just good Ruby developers like you and me writing simple code. 👊
If you were to do a little more digging in the the Ruby Process
you might be able to develop your own customized Benchmark module.
Top comments (0)