performance

What this skill does

# Ruby Performance Optimization

Guide to profiling, benchmarking, and optimizing Ruby code.

## Profiling First

Always measure before optimizing. Identify bottlenecks with profiling tools.

### benchmark-ips

Compare implementations with statistical significance:

```ruby
require "benchmark/ips"

Benchmark.ips do |x|
  x.report("map + flatten") do
    [[1, 2], [3, 4]].map { |a| a * 2 }.flatten
  end

  x.report("flat_map") do
    [[1, 2], [3, 4]].flat_map { |a| a * 2 }
  end

  x.compare!
end

# Output:
# flat_map:  1234567.8 i/s
# map + flatten: 987654.3 i/s - 1.25x slower
```

### stackprof (CPU Profiling)

```ruby
require "stackprof"

StackProf.run(mode: :cpu, out: "tmp/stackprof.dump") do
  # Code to profile
  1000.times { expensive_operation }
end

# View results
# $ stackprof tmp/stackprof.dump --text
# $ stackprof tmp/stackprof.dump --method 'YourClass#method'
```

### memory_profiler

```ruby
require "memory_profiler"

report = MemoryProfiler.report do
  # Code to analyze
  data = process_large_dataset
end

report.pretty_print
# Shows allocated objects, retained objects, memory by gem/file/location
```

## Memory Optimization

### Reduce Object Allocations

```ruby
# Bad: Creates many intermediate objects
def bad_join(items)
  result = ""
  items.each do |item|
    result = result + item.to_s + ", "  # Creates new strings each time
  end
  result
end

# Good: Modify in place
def good_join(items)
  result = +""  # Unfrozen empty string
  items.each do |item|
    result << item.to_s << ", "
  end
  result
end

# Best: Use built-in
items.join(", ")
```

### Frozen String Literals

```ruby
# frozen_string_literal: true

# All string literals are now frozen (immutable)
# Reduces memory by reusing string objects
name = "Alice"  # Frozen, shared across uses
```

### Symbol vs String

```ruby
# Symbols are interned (shared in memory)
# Good for hash keys, identifiers
hash = { name: "Alice", age: 30 }  # Symbol keys

# Strings are mutable, not shared
# Good for user data, content
hash = { "user_input" => value }
```

### Lazy Enumerables

```ruby
# Bad: Loads entire file into memory
File.readlines("large.txt").select { |l| l.include?("ERROR") }.first(10)

# Good: Processes line by line, stops early
File.foreach("large.txt")
    .lazy
    .select { |l| l.include?("ERROR") }
    .first(10)
```

### Object Pooling

```ruby
class ConnectionPool
  def initialize(size:)
    @available = Array.new(size) { create_connection }
    @mutex = Mutex.new
  end

  def with_connection
    conn = checkout
    yield conn
  ensure
    checkin(conn)
  end

  private

  def checkout
    @mutex.synchronize { @available.pop }
  end

  def checkin(conn)
    @mutex.synchronize { @available.push(conn) }
  end

  def create_connection
    # Expensive connection creation
  end
end
```

## Algorithm Optimization

### Choose Right Data Structures

```ruby
require "set"

# O(n) lookup
array = [1, 2, 3, 4, 5]
array.include?(3)  # Slow for large arrays

# O(1) lookup
set = Set[1, 2, 3, 4, 5]
set.include?(3)  # Fast

# O(1) lookup with value
hash = { 1 => true, 2 => true, 3 => true }
hash.key?(3)  # Fast
```

### Avoid N+1 in Ruby Code

```ruby
# Bad: O(n*m) - nested iteration
users.each do |user|
  user.orders.each do |order|
    # O(n*m) iterations
  end
end

# Better: Pre-group data
orders_by_user = orders.group_by(&:user_id)
users.each do |user|
  user_orders = orders_by_user[user.id] || []
  # O(n) + O(m) iterations
end
```

### Memoization

```ruby
class ExpensiveCalculator
  def result
    @result ||= compute_expensive_result
  end

  # For methods with arguments
  def calculate(n)
    @cache ||= {}
    @cache[n] ||= expensive_computation(n)
  end

  # Clear cache when needed
  def clear_cache!
    @result = nil
    @cache = nil
  end
end
```

## Garbage Collection

### Understanding GC

```ruby
# Check GC stats
GC.stat
# => { count: 42, heap_allocated_pages: 100, ... }

# Manual GC (usually not needed)
GC.start

# Disable during benchmarks (not in production)
GC.disable
# ... run benchmark ...
GC.enable
```

### Reduce GC Pressure

```ruby
# Bad: Many short-lived objects
def bad_process(items)
  items.map { |i| i.to_s }
       .map { |s| s.upcase }
       .map { |s| s.strip }
end

# Good: Chain operations, fewer intermediates
def good_process(items)
  items.map { |i| i.to_s.upcase.strip }
end

# Best: Modify in place when possible
def best_process(items)
  items.each do |i|
    # Modify i in place if possible
  end
end
```

### GC Tuning Environment Variables

```bash
# Increase heap slots (reduce GC frequency)
# Note: These values are examples. Profile your application first
# and adjust based on actual memory usage patterns.
RUBY_GC_HEAP_INIT_SLOTS=600000

# Increase malloc limit before GC
RUBY_GC_MALLOC_LIMIT=64000000

# Growth factor for heap
RUBY_GC_HEAP_GROWTH_FACTOR=1.25
```

**Warning:** GC tuning values should be determined through profiling your specific application. Avoid cargo-cult optimization by copying values without understanding your application's memory patterns. Always measure before and after tuning.

## Concurrency

### Threads for I/O

```ruby
require "concurrent"

# Thread pool for I/O-bound work
pool = Concurrent::ThreadPoolExecutor.new(
  min_threads: 5,
  max_threads: 10,
  max_queue: 100
)

urls.each do |url|
  pool.post do
    fetch_url(url)
  end
end

pool.shutdown
pool.wait_for_termination
```

### Ractors for CPU

```ruby
# True parallelism for CPU-bound work
ractors = data.each_slice(data.size / 4).map do |chunk|
  Ractor.new(chunk) do |items|
    items.map { |item| expensive_computation(item) }
  end
end

results = ractors.flat_map(&:take)
```

### Async for I/O

```ruby
require "async"

Async do
  results = urls.map do |url|
    Async do
      fetch_url(url)
    end
  end.map(&:wait)
end
```

## Common Optimizations

### String Building

```ruby
# Bad
result = ""
items.each { |i| result += i.to_s }

# Good
result = items.map(&:to_s).join

# Also good for large strings
io = StringIO.new
items.each { |i| io << i.to_s }
result = io.string
```

### Array Operations

```ruby
# Use appropriate methods
array.any? { |x| x > 5 }  # Stops at first match
array.all? { |x| x > 5 }  # Stops at first failure
array.find { |x| x > 5 }  # Returns first match

# Avoid repeated operations
# Bad
array.count > 0   # Counts all elements
# Good
array.any?        # Stops immediately

# Bad
array.select { ... }.first
# Good
array.find { ... }
```

### Hash Operations

```ruby
# Use fetch with default
hash.fetch(:key, default_value)
hash.fetch(:key) { compute_default }

# Transform keys/values efficiently
hash.transform_keys(&:to_sym)
hash.transform_values(&:to_s)

# Merge in place
hash.merge!(other_hash)  # Modifies hash
```

## Additional Resources

### Reference Files

- **`references/profiling-guide.md`** - Detailed profiling workflows and tool usage