Concurrency in Ruby is all the rage these days, and people can't seem to agree whether Threads, Fibers, event loops, or actors are the best solution. But did you ever consider that your *sequential* Ruby program might be concurrent, with nary a Thread, Fiber, or callback in sight? Well, it happened to me. This is the story of how accidental concurrency (also known as re-entrancy) broke my brain multiple times over the course of two years, spawned flamewars on Twitter, long blog posts, and the various solutions I took to solve the problem. Along the way we'll illuminate some subtleties of concurrent programming in Ruby, differences between several Ruby implementations, and how we can all write code that is friendlier when accidental concurrency strikes.

1. A Case of
Accidental
Concurrency
Sean Cribbs
@seancribbs

3. I work for Basho
We make

4. Distributed Systems Experts

5. Ruby Concurrency

6. Processes
Ruby Concurrency

7. Processes
Threads
Ruby Concurrency

8. Processes Reactors
Threads
Ruby Concurrency

9. Processes Reactors
Threads
Ruby Concurrency
Fibers

10. Processes Reactors
Threads
Ruby Concurrency
Actors
Fibers

11. Processes Reactors
Threads
Ruby Concurrency
Actors
Fibers
Sequential Code

12. Riak Streaming
Operations
http://thecatchandthehatch.com/pages/river-resources/

13. Streaming Ops
client server
stream_me

14. Streaming Ops
client server
stream_me
result
result
result
done

15. Streaming Ops
client server
stream_me
result
result
result
done
list-keys & MapReduce

16. Stream in Ruby
# Request a streamed operation
client.stream_something do |result|
process(result)
end

17. Stream in Ruby
# Request a streamed operation
client.stream_something do |result|
process(result)
end
# Stream via curb
if block_given?
curl.on_body {|c| yield c; c.size }
else
curl.on_body # Clear out the callback
end

19. Curl::Err::MultiBadEasyHandle
:
Invalid easy handle

20. Curling Back
def curl
@curl ||= Curl::Easy.new
end

21. Curling Back
def curl
@curl ||= Curl::Easy.new
end
def curl
Thread.current[:curl] ||= Curl::Easy.new
end

22. "The first basic rule is that you must
never simultaneously share a libcurl
handle (be it easy or multi or whatever)
between multiple threads."
-- libcurl docs

23. NO THREADS you must
"The first basic rule is that
never simultaneously share a libcurl
handle (be it easy or multi or whatever)
between multiple threads."
-- libcurl docs

24. Realization
• curl yields to block BEFORE return
• block tries to reuse handle while
connection is processing

25. Re-entrant
"In computing, a computer program or
subroutine is called reentrant if it can
be interrupted in the middle of its
execution and then safely called again
("re-entered") before its previous
invocation's complete execution."
Wikipedia

26. Re-entrant
"...a subroutine can fail to be reentrant
if it relies on a global variable to remain
unchanged but that variable is modified
when the subroutine is recursively
invoked."
Wikipedia

27. Re-entrant
"...a subroutine can fail to be reentrant
if it relies on a global variable to remain
unchanged but that variable is modified
when the subroutine is recursively
invoked."
Wikipedia

28. Solution #1: Fibers

29. Solution #1: Fibers
if block_given?
_curl = curl
Fiber.new {
f = Fiber.current
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
end
loop do
yield Fiber.yield
end
}.resume
else
# ...

30. Solution #1: Fibers
if block_given?
_curl = curl local curl
Fiber.new {
f = Fiber.current
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
end
loop do
yield Fiber.yield
end
}.resume
else
# ...

31. Solution #1: Fibers
if block_given?
_curl = curl
Fiber.new { open fiber
f = Fiber.current
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
end
loop do
yield Fiber.yield
end
}.resume
else
# ...

32. Solution #1: Fibers
if block_given?
_curl = curl
Fiber.new {
f = Fiber.current this fiber
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
end
loop do
yield Fiber.yield
end
}.resume
else
# ...

33. Solution #1: Fibers
if block_given?
_curl = curl
Fiber.new {
f = Fiber.current
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
resume on chunk
end
loop do
yield Fiber.yield
end
}.resume
else
# ...

34. Solution #1: Fibers
if block_given?
_curl = curl
Fiber.new {
f = Fiber.current
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
end
loop do wait for chunk,
yield Fiber.yield yield chunk,
end repeat
}.resume
else
# ...

35. Solution #1: Fibers
if block_given?
_curl = curl
Fiber.new {
f = Fiber.current
_curl.on_body do |chunk|
f.resume(chunk); chunk.size
end
loop do
yield Fiber.yield
end start the fiber/loop
}.resume
else
# ...

36. How it Works
• Stream block runs INSIDE the Fiber
•Fibers have Thread locals
• Thread.current[:curl] is isolated

38. Solution #2: Pump

39. class Pump
def initialize(block)
@fiber = Fiber.new do
loop do
block.call Fiber.yield
end
end
@fiber.resume
end
def pump(input)
@fiber.resume input
input.size if input.respond_to?(:size)
end
def to_proc

40. Simpler
if block_given?
curl.on_body(&Pump.new(block))
else
curl.on_body
end

41. COMMENCE
TWITTERSTORM
http://seancribbs.com/tech/2011/03/08/how-ripple-uses-
fibers
Photos by James Duncan Davidson, O’Reilly RailsConf 2010
http://www.flickr.com/photos/oreillyconf/4686730445/ http://www.flickr.com/photos/oreillyconf/4683464653/

42. “There are three hard
things in Computer
Science: naming, cache
invalidation, and
connection pooling.”
Andy Gross, Basho
Architect
Jan 2012

43. Solution #3:
Connection Pool

44. @aphyr

45. class Pool::Element
attr_accessor :object, :owner
def initialize(object)
@object = object
@owner = nil
end
def lock
@owner = Thread.current
end
def unlock
@owner = nil
end
end

46. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

47. def take(opts = {}) # alias >> take
result = nil result var
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

48. def take(opts = {}) # alias >> take
result = nil
begin
element = nil pool element
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

49. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do grab pool lock
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

50. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end find a connection
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

51. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
all claimed!
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

52. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end add new
element.lock
end conn to
result = yield element.object
rescue BadResource
pool
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

53. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock claim it
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

54. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object call block
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
end
result
end

55. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element
cleanup
end baddies
result
end

56. def take(opts = {}) # alias >> take
result = nil
begin
element = nil
@lock.synchronize do
element = pool.find {|e| e.unlocked? }
unless element
resource = opts[:default] || @open.call
element = Element.new(resource)
@elements << element
end
element.lock
end
result = yield element.object
rescue BadResource
delete_element(element) and raise
ensure
element.unlock if element release
end
result
end

57. # If you actually do this request, you'll get a
# warning. So don't.
objects = []
pool.take do |conn|
conn.list_keys("ruby") do |keys|
keys.each do |k|
pool.>> {|c| objects << c.get("ruby", k) }
end
end
end

58. # If you actually do this request, you'll get a
# warning. So don't.
objects = []
client.list_keys("ruby") do |keys|
keys.each do |k|
objects << client.get("ruby", k)
end
end

59. Becoming Less
“Accidental”

60. Fix Leaky Scope

61. Be Explicit

62. Thanks!
@seancribbs