TruffleRuby - High-Performance Ruby on GraalVM

GraalVM Architecture

• Truffle Framework: Language implementation framework
• Graal Compiler: Advanced JIT compiler written in Java
• Substrate VM: Ahead-of-time compilation for native images
• Polyglot Engine: Cross-language interoperability

Supported Languages

Peak Performance

• Exceptional Speed: Can be 10-100x faster than MRI for optimizable code
• Advanced Optimizations: Sophisticated inlining, escape analysis
• Speculative Optimization: Adaptive compilation based on runtime behavior
• Partial Evaluation: Truffle framework optimizations

Warmup Considerations

• Slow Startup: Can take 30+ seconds to reach peak performance
• Memory Usage: Higher memory consumption during warmup
• JIT Compilation: Requires sustained execution for optimization
• Profiling Overhead: Initial execution includes profiling costs

Benchmark Example

# Fibonacci benchmark showing warmup effect
def fibonacci(n)
  return n if n <= 1
  fibonacci(n - 1) + fibonacci(n - 2)
end

# Cold performance (first run)
start_time = Time.now
fibonacci(35)
cold_time = Time.now - start_time

# Warm up (run multiple times)
10.times { fibonacci(35) }

# Warm performance
start_time = Time.now
fibonacci(35)
warm_time = Time.now - start_time

puts "Cold: #{cold_time}s, Warm: #{warm_time}s"
# TruffleRuby shows dramatic improvement after warmup

Creating Native Images

# Install native-image component
gu install native-image

# Compile Ruby script to native executable
ruby --native --output=myapp script.rb

# Advanced native image options
ruby --native \
     --output=myapp \
     --vm.XX:+UseG1GC \
     --vm.Xmx2g \
     script.rb

# Run the native executable
./myapp

Native Image Benefits

• Instant Startup: No JVM startup overhead
• Lower Memory: Reduced memory footprint
• Self-Contained: No need for Ruby/JVM installation
• Cloud-Native: Ideal for serverless and containers

Native Image Limitations

• No JIT: No runtime optimization (peak performance lower)
• Ahead-of-Time: All code paths must be known at build time
• Reflection Limitations: Dynamic features may not work
• Build Time: Compilation can take several minutes

Ruby + JavaScript

# Load JavaScript code from Ruby
js_code = %{
  function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
  }
  fibonacci;
}

# Execute JavaScript and get function
js_fibonacci = Polyglot.eval('js', js_code)

# Call JavaScript function from Ruby
result = js_fibonacci.call(10)
puts result  # Uses fast JavaScript implementation

Ruby + Python

# Use Python libraries from Ruby
numpy = Polyglot.eval('python', 'import numpy; numpy')

# Create numpy array
array = numpy.array([1, 2, 3, 4, 5])

# Call numpy functions
mean_value = numpy.mean(array)
puts "Mean: #{mean_value}"

# Convert between Ruby and Python objects
ruby_array = [1, 2, 3]
python_list = Polyglot.eval('python', 'list')(ruby_array)

Language Interop Benefits

• Best Tool for Job: Use optimal language for each task
• Library Access: Access ecosystems from other languages
• Shared Optimization: Cross-language optimizations
• Zero-Copy: Share objects between languages efficiently

LLVM Sulong Support

TruffleRuby can run C extensions through LLVM Sulong, providing compatibility with many native gems.

# Install sulong component
gu install llvm-toolchain

# Enable native extensions
ruby --experimental-options --llvm script.rb

# Install gems with C extensions
gem install json  # Works with Sulong
gem install nokogiri  # May require configuration

Compatibility Status

Alternative Approaches

• Pure Ruby Alternatives: Use Ruby implementations when available
• Java Alternatives: Leverage Java libraries for similar functionality
• Polyglot Solutions: Use other GraalVM languages
• FFI: Use Foreign Function Interface for native libraries

Perfect For

• CPU-Intensive Applications: Mathematical computing, algorithms
• Long-Running Services: Background processors, daemons
• High-Performance APIs: Need maximum throughput
• Polyglot Applications: Integrating multiple languages
• Research and Experimentation: Exploring language optimization
• Cloud-Native (Native Images): Serverless, fast startup

Consider Alternatives For

• Short-Lived Scripts: CLI tools, build scripts
• Heavy C Extension Use: Applications relying on many native gems
• Conservative Environments: Where stability is critical over performance
• Simple Web Applications: Basic CRUD apps may not benefit
• Development/Testing: Slower feedback loop due to warmup