Ruby Concurrency and EventMachine

Ruby Concurrency
...and the mysterious case of the Reactor Pattern

Christopher Spring

WTF the EventMachine
and why should I care?

Resource utilization

• Lots of IO (90/10)
• Disk
• Network
• system()
• Lots of cores

http://www.mikeperham.com/2010/01/27/scalable-ruby-processing-with-eventmachine/

Ruby concurrency basics

• Threads
• Fibers
• Processes

Threading Models
1: N

1 :1

M :N

Threading Models
1: N

Kernel Threads 1 :1 User Threads

M :N

Threading Models
1: N

1 :1

M :N

Kernel Threads User Threads

Threading Models
1: N
• Green Threads
• Ruby 1.8 1 :1

• Pros/Cons
M :N


Threading Models
1: N
• Native Threads
• Ruby 1.9 / jRuby 1 :1

• Pros/Cons
M :N


Threading Models
1: N

1 :1 ?
M :N


Threads

• Shared state and memory space

Threads

• Relatively light weight

Threads

• Relatively light weight
• Preemptive scheduling

Ruby Concurrency and EventMachine

Ruby has baggage: GIL

http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby/

Threads... suck

• Race conditions

Threads... suck

• Race conditions
• Deadlocks

Threads... suck

• Race conditions
• Deadlocks
• Hard to debug

Threads... suck

• Race conditions
• Deadlocks
• Hard to debug
• GIL

Fibers

• It’s a coroutine, dammit!

Fibers

• It’s a coroutine, dammit!
• “... [component to] generalize
subroutines to allow multiple entry
points for suspending and resuming
execution at certain locations.”

file_iterator = Fiber.new do
file = File.open('stuff.csv', 'r')
while line = file.gets
Fiber.yield line
end
file.close
end

3.times{ file_iterator.resume }

# => line 1
# => line 2
# => line 3

Fibers

• Cooperative Scheduling
• Very lightweight
• Maintains state
• Great for: cooperative tasks, iterators,
inﬁnite lists and pipes

def interpret_csv( csv_source )
Fiber.new do
while csv_source.alive?
str = csv_source.resume
Fiber.yield str.split(',').map(&:strip)
end
end
end

def file_iterator(file_name)
Fiber.new do
file = File.open(file_name, 'r')
while line = file.gets
Fiber.yield line
end
file.close
end
end

interpret_csv( file_iterator('stuff.csv') ).resume

# => [...]

Client Client Client Client

IO Stream

Event Handler A Event Dispatcher
Event Handler B
Demultiplexer
Event Handler C
Event Handler D

Beneﬁts

• Non blocking IO
• Coarse grain concurrency
• No threads!
• Single Process

Limitations

• Hard to debug
• Dispatch to event handlers is synchronous
• Demultiplexer polling limits

require 'eventmachine'

class EchoServer < EM::Connection
def post_init
puts "New connecting"
end

def unbind
puts "Connection closed"
end

def receive_data(data) # unbuffered!!
puts "<< #{data}"
send_data ">> #{data}"
end
end

EM.run do
EM.start_server('127.0.0.1', 9000, EchoServer)
puts "Started server at 127.0.0.1:9000"
end # Runs till EM.stop called

# $ telnet localhost 9000
require 'eventmachine' # Hello
# >> Hello
class EchoServer < EM::Connection # Bye
def post_init # >> Bye
puts "New connecting"
end

def unbind
puts "Connection closed"
end

def receive_data(data) # unbuffered!!
puts "<< #{data}"
send_data ">> #{data}"
end
end

EM.run do
EM.start_server('127.0.0.1', 9000, EchoServer)
puts "Started server at 127.0.0.1:9000"
end # Runs till EM.stop called

Primitives

• run loop
• next_tick; add_timer; add_periodic_timer
• EM.defer
• EM::Queue
• EM::Channel

EM.run do
Defer
operation = Proc.new do
puts 'MapMap!!'
sleep 3
puts 'Done collecting data'
[1, 1, 2, 3, 5, 8, 13]
end

callback = Proc.new do |arr|
puts 'Reducing...'
sleep 1
puts 'Reduced'
puts arr.inject(:+)
EM.stop
end

EM.defer(operation, callback)
end

EM.run do
Defer #
#
#
MapMap!!
Done collecting data
Reducing...
# Reduced
operation = Proc.new do
# 33
puts 'MapMap!!'
sleep 3
puts 'Done collecting data'
[1, 1, 2, 3, 5, 8, 13]
end

callback = Proc.new do |arr|
puts 'Reducing...'
sleep 1
puts 'Reduced'
puts arr.inject(:+)
EM.stop
end

EM.defer(operation, callback)
end

EM.run do
Queue
queue = EM::Queue.new

EM.defer do
sleep 2; queue.push 'Mail 1'
end

mail_sender = Proc.new do |mail|
puts "Sending #{mail}"
EM.next_tick{ queue.pop(&mail_sender)}
end

queue.pop(&mail_sender)

end

Channel
EM.run do
channel = EM::Channel.new

EM.defer do
channel.subscribe do |msg|
puts "Received #{msg}"
end
end

EM.add_periodic_timer(1) do
channel << Time.now
end
end

class Mailer
include EM::Deferrable Deferrable
def initialize
callback do
sleep 1
puts 'Updated statistics!'
end

errback{ puts 'retrying mail'}
end

def send
rand >= 0.5 ? succeed : fail
end
end

EM.run do
5.times do
mailer = Mailer.new
EM.add_timer(rand * 5){ mailer.send}
end
end

class Mailer
include EM::Deferrable Deferrable
def initialize # Updating statistics!
callback do # Updating statistics!
sleep 1 # retrying mail
puts 'Updated statistics!'
end

errback{ puts 'retrying mail'}
end

def send
rand >= 0.5 ? succeed : fail
end
end

EM.run do
5.times do
mailer = Mailer.new
EM.add_timer(rand * 5){ mailer.send}
end
end

class Mailer
Stacked callbacks
include EM::Deferrable

EM.run do
def add_mailing(val)
m = Mailer.new
callback{
m.add_mailing(1)
sleep 1;
m.add_mailing(2)
puts "Sent #{val}"
m.connection_open!
}
end
EM.add_timer(1) do
m.connection_lost!
def connection_open!
EM.add_timer(2) do
puts 'Open connection'
m.add_mailing(3)
succeed
m.add_mailing(4)
end
m.connection_open!
end
def connection_lost!
end
puts 'Lost connection'
end
set_deferred_status nil
end
end

class Mailer
Stacked callbacks
include EM::Deferrable

EM.run do
def add_mailing(val)
m = Mailer.new
callback{ # Open connection
m.add_mailing(1)
sleep 1;
m.add_mailing(2) # Sent 1
puts "Sent #{val}"
m.connection_open! # Sent 2
}
end # Lost connection
EM.add_timer(1) do
# Open connection
m.connection_lost!
def connection_open! # Sent 3
EM.add_timer(2) do
puts 'Open connection'
m.add_mailing(3) # Sent 4
succeed
m.add_mailing(4)
end
m.connection_open!
end
def connection_lost!
end
puts 'Lost connection'
end
set_deferred_status nil
end
end

Gotchas

• Synchronous code will slow it down
• Use/Write libraries for EM
• Everything in the event loop must be async!

Summary

• It’s a blocking world!
• Alternative concurrency implementations
• Start playing with EM

Worth checking out

• EM-Synchrony:
https://github.com/igrigorik/em-synchrony
• Goliath:
https://github.com/postrank-labs/goliath

Links

• http://www.mikeperham.com
• http://www.igvita.com (!!)
• http://rubyeventmachine.com/

Ruby Concurrency and EventMachine

More Related Content

What's hot (20)

Viewers also liked (8)

Similar to Ruby Concurrency and EventMachine (20)

Recently uploaded (20)

Ruby Concurrency and EventMachine

Editor's Notes