Performance profiling basics in Ruby - Step-by-Step Execution

Concept Flow - Performance profiling basics

Start Program

↓

Run Code Section

↓

Measure Time Taken

↓

Record Resource Usage

↓

Analyze Results

↓

Identify Bottlenecks

↓

Optimize Code

↓

Repeat Profiling

↓

End Program

This flow shows how performance profiling measures code execution time and resource use to find slow parts and improve them.

Execution Sample

Ruby

require 'benchmark'

result = Benchmark.measure do
  sum = 0
  1_000_000.times { |i| sum += i }
end

puts result

This Ruby code measures how long it takes to sum numbers from 0 to 999,999.

Execution Table

Step	Action	Evaluation	Result
1	Start Benchmark.measure block	Begin timing	Timer started
2	Initialize sum	sum = 0	sum is 0
3	Loop 1,000,000 times	Add i to sum each iteration	sum accumulates values
4	End Benchmark.measure block	Stop timing	Timer stopped
5	Output result	Print elapsed time	Shows time taken to run loop

💡 Benchmark.measure finishes after loop completes and time is recorded

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 1,000,000	Final
sum	0	0 + 0 = 0	0 + 1 = 1	1 + 2 = 3	...	499999500000

Key Moments - 3 Insights

Why does Benchmark.measure wrap the code block?

Benchmark.measure starts timing before the block runs and stops after it finishes, so it measures exactly the code inside. See execution_table rows 1 and 4.

Does the sum variable affect the timing result?

Yes, because the loop does work adding to sum each time. If sum was not updated, the loop might be optimized away. See variable_tracker showing sum changes.

What does the output of Benchmark.measure show?

It shows the elapsed time and resource usage for the code block. This helps find slow parts to optimize. See execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3?

A The result is printed

B The loop runs 1,000,000 times adding i to sum

C The timer starts

D The sum variable is reset to zero

💡 Hint

Check execution_table row 3 describing the loop action

According to variable_tracker, what is the value of sum after 2 iterations?

A 1

B 3

C 0

D 2

💡 Hint

Look at variable_tracker row for sum after 2 iterations

If we remove the sum += i line, how would the timing change in execution_table?

A Timing would be longer because sum is not updated

B Timing would be the same

C Timing would be shorter because loop does less work

D Program would crash

💡 Hint

Consider execution_table row 3 where sum is updated each iteration

Concept Snapshot

Performance profiling in Ruby uses Benchmark.measure to time code blocks.
Wrap the code you want to measure inside Benchmark.measure do ... end.
It records how long the code takes to run.
Use this info to find slow parts and improve them.
Repeat profiling after changes to check improvements.

Full Transcript

Performance profiling basics in Ruby involve measuring how long parts of your code take to run. Using Benchmark.measure, you wrap the code block you want to test. When the program runs, it starts a timer before the block and stops it after. This gives you the elapsed time. For example, summing numbers from 0 to 999,999 inside Benchmark.measure shows how long that loop takes. Watching the sum variable change helps understand the work done. The output tells you the time used, so you can find slow spots and make your code faster. Profiling again after changes confirms if your improvements worked.

Practice

1. What is the main purpose of performance profiling in Ruby?

easy

A. To find slow parts of the code that need optimization

B. To add new features to the Ruby program

C. To check syntax errors in the code

D. To convert Ruby code into another language

Solution

1. Step 1: Understand the goal of profiling

   Performance profiling is used to measure how long parts of code take to run.

2. Step 2: Identify the main use

   It helps find slow parts so you can improve them.

3. Final Answer:

   To find slow parts of the code that need optimization -> Option A

4. Quick Check:

   Profiling = Find slow code [OK]

Hint: Profiling = finding slow code parts to speed up [OK]

Common Mistakes:

• Confusing profiling with debugging syntax errors
• Thinking profiling adds features
• Believing profiling translates code

2. Which Ruby gem is commonly used for performance profiling?

easy

A. nokogiri

B. rails

C. ruby-prof

D. rspec

Solution

1. Step 1: Recall common Ruby gems

   Rails is a web framework, Nokogiri is for XML/HTML parsing, RSpec is for testing.

2. Step 2: Identify profiling gem

   ruby-prof is the gem designed for performance profiling.

3. Final Answer:

   ruby-prof -> Option C

4. Quick Check:

   Profiling gem = ruby-prof [OK]

Hint: ruby-prof gem is for profiling Ruby code [OK]

Common Mistakes:

• Choosing Rails as a profiling tool
• Confusing testing gem RSpec with profiling
• Picking unrelated gems like Nokogiri

3. Given this Ruby profiling output snippet:

Method       | Total Time | Self Time
calculate    | 0.50       | 0.40
process      | 0.30       | 0.10
render       | 0.20       | 0.20

Which method should you optimize first to improve performance?

medium

A. calculate

B. render

C. All methods equally

D. process

Solution

1. Step 1: Understand self time meaning

   Self time shows how much time the method itself takes, excluding calls to others.

2. Step 2: Compare self times

   calculate has the highest self time (0.40), so it is the slowest part to optimize.

3. Final Answer:

   calculate -> Option A

4. Quick Check:

   Highest self time = calculate [OK]

Hint: Optimize method with highest self time first [OK]

Common Mistakes:

• Choosing method with highest total time instead of self time
• Thinking all methods need equal optimization
• Ignoring self time importance

4. What is wrong with this Ruby profiling code snippet?

require 'ruby-prof'
ruby-prof.start
# some code here
result = RubyProf.stop
puts result

medium

A. Missing require statement for ruby-prof

B. Not starting the profiler before code

C. No code to profile

D. Using puts directly on result object

Solution

1. Step 1: Check require and start

   require 'ruby-prof' and ruby-prof.start are correctly used.

2. Step 2: Understand result object usage

   result is a RubyProf::Profile object; printing it directly with puts won't show readable output.

3. Final Answer:

   Using puts directly on result object -> Option D

4. Quick Check:

   Print profiling result properly, not with puts [OK]

Hint: Use printer classes to display profiling results, not puts [OK]

Common Mistakes:

• Printing result object directly
• Forgetting to start profiler
• Not requiring ruby-prof gem

5. You want to profile a Ruby method heavy_task and save the results to a file in a readable format. Which code snippet correctly does this?

hard

A. require 'ruby-prof'
ruby-prof.start
heavy_task
result = RubyProf.stop
File.open('profile.txt', 'w') { |f| f.puts result }

B. require 'ruby-prof'
ruby-prof.start
heavy_task
result = RubyProf.stop
printer = RubyProf::FlatPrinter.new(result)
File.open('profile.txt', 'w') { |f| printer.print(f) }

C. require 'ruby-prof'
result = RubyProf.profile { heavy_task }
File.write('profile.txt', result.to_s)

D. require 'ruby-prof'
ruby-prof.start
heavy_task
result = RubyProf.stop
puts result.to_s > 'profile.txt'

Solution

1. Step 1: Understand profiling and printing

   ruby-prof returns a result object that needs a printer to format output.

2. Step 2: Check each option for correct usage

   require 'ruby-prof' ruby-prof.start heavy_task result = RubyProf.stop printer = RubyProf::FlatPrinter.new(result) File.open('profile.txt', 'w') { |f| printer.print(f) } uses FlatPrinter to format and writes to file correctly. require 'ruby-prof' ruby-prof.start heavy_task result = RubyProf.stop File.open('profile.txt', 'w') { |f| f.puts result } writes raw object, require 'ruby-prof' result = RubyProf.profile { heavy_task } File.write('profile.txt', result.to_s) misuses to_s, require 'ruby-prof' ruby-prof.start heavy_task result = RubyProf.stop puts result.to_s > 'profile.txt' misuses puts redirection.

3. Final Answer:

   Option B code snippet -> Option B

4. Quick Check:

   Use printer to save profiling output [OK]

Hint: Use RubyProf printers to save readable profiling results [OK]

Common Mistakes:

• Writing raw result object to file
• Using puts with redirection incorrectly
• Not using a printer to format output