1. Concurrency in Ruby
Marco Borromeo - @borros
Italian Ruby Day - Milan - 15 June 2012

2. Concurrency - Why?
Fill up all those cores!

3. Concurrency - Why?
Fill up all those cores!
Ruby is slow - Just add some more mongrels there

4. Concurrency - Why?
Fill up all those cores!
Ruby is slow - Just add some more mongrels there

5. How to achieve concurrency
Multiple processes / forking
Threads
Fibers

6. Multiple processes / forking
Most commonly used solution to gain concurrency in Ruby

7. Multiple processes / forking
Most commonly used solution to gain concurrency in Ruby
No shared states between running processes. You need to use DRb, a
message bus like RabbitMQ

8. Multiple processes / forking
Most commonly used solution to gain concurrency in Ruby
No shared states between running processes. You need to use DRb, a
message bus like RabbitMQ
... or some shared data store like MySQL

9. Multiple processes / forking
Most commonly used solution to gain concurrency in Ruby
No shared states between running processes. You need to use DRb, a
message bus like RabbitMQ
... or some shared data store like MySQL

10. Multiple processes / forking
Most commonly used solution to gain concurrency in Ruby
No shared states between running processes. You need to use DRb, a
message bus like RabbitMQ
... or some shared data store like MySQL
Forked processses can read the state of the program before the fork, but
updates wont be shared

11. Multiple processes / forking
LOT of memory used!
5 Rails apps is something like 45MB * 5 = 255MB!
Unix copy-on-write (CoW) comes to help: no need to copy the whole
memory into the forked process, and only the data changed after the fork
will be copied and modified. but...

12. Multiple processes / forking
Ruby Garbage Collector (GC) will write to every object every time
it will run, so the whole process memory will be then copied.
Basically, Ruby loses all the benefits of CoW.

13. Multiple processes / forking
Passenger fixed the copy-on-write issues creating a CoW-
friendly GC, and it will be integrated into Ruby 2.0

14. Multiple processes / forking
Passenger fixed the copy-on-write issues creating a CoW-
friendly GC, and it will be integrated into Ruby 2.0
Rubinius is CoW friendly

15. How to achieve concurrency
Multiple processes / forking
Threads
Fibers

16. Threads
Ruby 1.8 has "green threads". They are scheduled by the VM,
and emulate multithreaded environments even if they are not.
Ruby 1.9 has OS threads.
Preemptive scheduling

17. Threads
Both 1.8 and 1.9 have the Global Interpreter Lock (GIL).
Having GIL means that any time one thread is running Ruby
code, no other thread can be running Ruby code.
Even if you have multiple threads, you can only use at most 1
core of your CPU at a time.

18. Threads
Race conditions, dead locks, synchronizing...

19. Threads
Race conditions, dead locks, synchronizing...

20. Threads
Race conditions, dead locks, synchronizing...
... JRuby manages threads very well, has no GIL and let you
use all your cores.

21. Threads
Race conditions, dead locks, synchronizing...
... JRuby manages threads very well, has no GIL and let you
use all your cores.
Rubinius is working on removing GIL

22. How to achieve concurrency
Multiple processes / forking
Threads
Fibers

23. Fibers
Natively available only in Ruby 1.9
They are like simplified threads, but they aren't
scheduled by the VM but by the programmer
Faster than threads, and use less memory

24. Fibers

25. Fibers
They still suffer the GIL presence.

26. Recap

27. Recap
Forking

28. Recap
Forking
GC prevents us to have a proper memory management

29. Recap
Forking
GC prevents us to have a proper memory management
Threads

30. Recap
Forking
GC prevents us to have a proper memory management
Threads
Difficult to manage
Difficult to debug in production
GIL prevents us to have concurrency

31. Recap
Forking
GC prevents us to have a proper memory management
Threads
Difficult to manage
Difficult to debug in production
GIL prevents us to have concurrency
Fibers

32. Recap
Forking
GC prevents us to have a proper memory management
Threads
Difficult to manage
Difficult to debug in production
GIL prevents us to have concurrency
Fibers
Difficult to debug in production
GIL prevents us to have concurrency

33. No Concurrency, sorry.

34. No Concurrency, sorry.

35. Blocking I/O
90% I/O
10% Code Execution

36. Reactor Pattern
Application server (AS) receives a request from a browser
AS queues the request in the Reactor
Reactor process the request, passing the control to our App
In order to process the request, our app needs to perform some API
queries over third-party services

37. Reactor Pattern
Application server (AS) receives a request from a browser
AS queues the request in the Reactor
Reactor process the request, passing the control to our App
In order to process the request, our app needs to perform some API
queries over third-party services
...zZzZzzZzZzZ...

38. Reactor Pattern
Application server (AS) receives a request from a browser
AS queues the request in the Reactor
Reactor process the request, passing the control to our App
In order to process the request, our app needs to perform some API
queries over third-party services
...zZzZzzZzZzZ...

39. Reactor Pattern
Our app makes the http request to the third-party service, using an async
library (em-http) and provides a callback to be executed when a reply is
received
Control returns to the Reactor
Reactor pulls the next event from the queue and executes it

40. Reactor Pattern
Earlier HTTP API call returns (or fails!) and the callback is enqueued into the
Reactor
Control returns to the Reactor
Reactor starts executing the callback which processes the results of the API
request, builds a response and sends it to the browser.
Done

41. Blocking I/O
Everything has the advantage of being concurrent
without having to be thread-safe.
It is a "cooperative multitasking"
(while Threads have a “Preemptive scheduling“ approach)

42. EventMachine
Is the Ruby implementation of the Reactor Pattern
::DeferrableChildProcess - Wait for a process to exit
::FileStreamer - Streams a file over a connection
::FileWatch - Monitors a file, get notified when it gets deleted, modified or
moved
::PeriodicTimer - Executes something every interval seconds

43. EventMachine
Is the Ruby implementation of the Reactor Pattern
::Protocols::HttpClient ::Protocols::SmtpServer
::Protocols::Memcache ::Protocols::Socks4
::Protocols::Postgres3 ::Protocols::Stomp
::Protocols::SmtpClient

44. EventMachine
Issues:
Not so very well documented
Difficult to adopt for "syncronous programmers"
Doesn't play well with actual web frameworks

45. EventMachine

46. EventMachine
EventMachine.run {
page = EventMachine::HttpRequest.new('http://github.com/').get
page.errback { p "GitHub is Down. Everybody run for your life!" }
page.callback {
about = EventMachine::HttpRequest.new('http://github.com/api/v2/json/
repos/show/schacon).get
about.callback { }
about.errback { }
}
}

47. EM-Syncrony
"Collection of convenience classes and primitives to help untangle evented
code, plus a number of patched EM clients to make them Fiber aware."
EventMachine.synchrony do
homepage = EventMachine::HttpRequest.new("http://github.com/").get
apiResponse = EventMachine::HttpRequest.new("'http://github.com/api/v2/
json/repos/show/schacon").get
p "No callbacks! Fetched API: #{apiResponse}"
EventMachine.stop
end

48. EM-Syncrony
mysql2
activerecord Other clients:
em-http-request em-redis
em-memcached hiredis
em-mongo
mongoid
AMQP

49. Sinatra::Synchrony
EventMachine + EM-Syncrony
Rack::FiberPool
em-http-request
em-resolv-replace
Patches TCPSocket (via EM-Syncrony) (!)
Patches Rack::Test

50. Sinatra::Synchrony
gem install sinatra-synchrony
require 'sinatra/synchrony'
register Sinatra::Synchrony

51. Thanks!
Marco Borromeo
@borros
marco@continuityapp.com