Ruby 3.3 Performance Overhaul: Code Faster, Garbage Less! ??

Hello, Ruby enthusiasts! ??? Ready to take a wild ride through the latest performance boosts in Ruby? ?? Buckle up, because things are about to get fast and furious in the world of object shapes, garbage collection, and memory optimization

1. defined?(@ivar) Just Got a Turbo Boost!

Ever wondered why checking if an instance variable is defined felt like a drag? Well, Ruby’s new Object Shapes optimization has hit the nitro button. Your code is now sleeker, faster, and more efficient—like switching from a bicycle to a sports car. ?????

Example:

Before the optimization, Ruby had to check each object’s individual shape to see if an instance variable was defined, which was relatively slow. Now, with Object Shapes, it’s much faster.

class Car
  def initialize
    @speed = 100
  end

  def turbo_boost
    if defined?(@speed)
      @speed *= 2
    else
      @speed = 50
    end
  end
end

car = Car.new
puts car.turbo_boost # => 200
        

With the optimization, checking defined?(@speed) is now quicker, making your code more performant.

2. Name Resolution: Now with Instant Interruptions!

Ever been stuck waiting for Socket.getaddrinfo to resolve a name, only to wish you could interrupt it? Guess what? Now you can! In environments with pthreads, name resolution is no longer the boss of you. Cut the delay, and keep your app running smooth like butter. ??

Example:

Imagine a situation where you’re trying to resolve a domain name, but the request hangs. Previously, there was no way to interrupt this operation.

require 'socket'

Thread.new do
  begin
    addr_info = Socket.getaddrinfo("www.example.com", nil)
    puts addr_info
  rescue Interrupt
    puts "Name resolution interrupted!"
  end
end

# Simulating an interrupt
sleep 1
Thread.main.raise Interrupt
        

With the latest improvement, you can now interrupt Socket.getaddrinfo, making your app more responsive.

3. Garbage Collector: Less Garbage, More Speed!

Ruby’s Garbage Collector (GC) just got a major overhaul. Here’s how:

a. Young Objects Stay Young

No more premature promotions of young objects to the old generation. Your app will run smoother with fewer GC interruptions, and that’s a win for everyone. ??

Example:

Consider a scenario where a lot of objects are created and then quickly discarded. Previously, these objects might have been prematurely promoted to the old generation, causing unnecessary major GC cycles.

100.times do
  arr = Array.new(1000) { "I am young" }
  # These objects will be quickly discarded
end

# Previously, this could have triggered a major GC cycle
# Now, with better object age tracking, these stay in the young generation longer
        

b. Tune It to Your Needs

The new REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO lets you control when a major GC collection is triggered. Think of it as having a remote control to manage your app’s memory usage. ??

Example:

You can now fine-tune the GC behavior by setting the REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO.

GC::Profiler.enable

# Set the new ratio
GC::set_params(remembered_wb_unprotected_objects_limit_ratio: 0.01)

# Create some objects
1000.times { "I am just passing by" }

GC.start # This will now trigger less frequently based on the new ratio
        

c. Write Barriers Everywhere

With more core types now equipped with Write Barriers, minor GC times are down, and major GC collections happen less frequently. Translation? Your app just got a speed boost. ??

Example:

Here’s how Write Barriers improve performance:

require 'bigdecimal'

# Operations on BigDecimal objects
10.times do
  num = BigDecimal("123456789.123456789")
  num += BigDecimal("1.000000001")
end

# With Write Barriers, the GC is smarter about handling these objects
        

4. Variable Width Allocation: Compact and Quick!

Classes like Hash, Time, and Thread::Backtrace now use Variable Width Allocation. This means they’re faster to allocate and free, use less memory, and reduce heap fragmentation. It’s like giving your app a personal trainer—leaner, faster, and ready for action! ???♂?

Example:

Consider the impact of Variable Width Allocation on Hash objects:

hash = {}
1000.times { |i| hash[i] = "value_#{i}" }

# Previously, this would take more memory and time to allocate
# Now, with Variable Width Allocation, it's more efficient
        

This change makes Hash and other core classes more memory-efficient and quicker to handle large datasets.

5. Weak References: Garbage Collector’s New Best Friend!

Support for weak references has been added to the GC. It’s like giving Ruby a sixth sense—knowing exactly when to let go and when to hold on, optimizing performance without breaking a sweat. ??

Example:

Weak references allow objects to be garbage collected while still being referenced, which is useful in caching scenarios.

require 'weakref'

class Cache
  def initialize
    @data = WeakRef.new({})
  end

  def fetch(key)
    @data[key] ||= compute_expensive_value(key)
  end

  private

  def compute_expensive_value(key)
    "Expensive value for #{key}"
  end
end

cache = Cache.new
cache.fetch(:foo) # => "Expensive value for foo"

# The object can now be garbage collected if memory is needed
        

With weak references, you can cache data without worrying about memory leaks.

Final Thoughts

Ruby’s latest performance improvements are not just tweaks; they’re full-on power-ups. Whether you’re building a small app or a large-scale system, these upgrades mean you’ll spend less time worrying about performance and more time enjoying the coding journey. ??

Remember, in the world of development, every millisecond counts—so why not let Ruby do the heavy lifting? ????

#RubyPerformance #Ruby3 #GarbageCollection #CodingTips #DeveloperLife