A rough guide to Fibers in Ruby 1.9. Given at the February 2010 meeting of LRUG, using the 20x20 format, hence the brevity.

1. Some rough fibrous
material
A 20x20 guide to Fibers in Ruby 1.9
Murray Steele - LRUG February 2010

2. What are fibers?
• coroutines
• cooperative multitasking

3. Detour #1: subroutines
vs. coroutines
• sub-routines
• every function you’ve ever written
• single entry-point & single exit
• co-routines
• single entry-point, multiple exit & re-
entry points

4. Detour #1.a:
subroutines
def a_sub_routine( )
CPU
end

5. Detour #1.a:
subroutines
def a_sub_routine( )
return CPU
end

6. Detour #1.b:
subroutines
def a_sub_routine( )
return CPU
end

7. Detour #1.b:
subroutines
def a_sub_routine( )
def a_sub_routine( )

return
end
return CPU
end

8. Detour #1.c:
coroutines
def a_co_routine( )
CPU
end

9. Detour #1.c:
coroutines
def a_co_routine( )
CPU
yield
resume
end

10. Detour #1.d:
coroutines
def a_co_routine( )
CPU
end

11. Detour #1.d:
coroutines
def a_co_routine( )
yield
yield CPU
yield resume
end

12. Detour #2: multitasking
• pre-emptive multitasking
• standard thread model
• locking & state issues
• co-operative multitasking
• programmer control

13. Detour #2.a:
pre-emptive
time
thread α
shared data
thread β

14. Detour #2.a:
pre-emptive
time
thread α
shared data
thread β

15. Detour #2.b:
co-operative
time
fiber α
shared data
fiber β

16. Detour #2.b:
co-operative
time
fiber α
yield
shared data
fiber β

17. Back on track:
finally some code
hello_lrug = Fiber.new do
i=1
loop do
Fiber.yield "Hello LR#{'U' * i}G!"
i += 1
end
end

18. Using fibers
hello_lrug.resume #=> "Hello LRUG!"
4.times { puts hello_lrug.resume }
# outputs:
# "Hello LRUUG!"
# "Hello LRUUUG!"
# "Hello LRUUUUG!"
# "Hello LRUUUUUG!"

19. Using fibers
means never
having
to say
you’re finished

20. Detour #1.1.2.3.5
def fib(n)
if (0..1).include? n
n
elsif n > 1
fib(n-1) + fib(n-2)
end
end
puts fib(6)

21. Detour #1.1.2.3.5.8
fib = Fiber.new do
x, y = 0, 1
loop do
Fiber.yield y
x, y = y, x + y
end
end
6.times { puts fib.resume }

22. What use is a fiber?
lrug = ['L','R','U','G']
enum = lrug.map
.with_index
enum.each {|*l| puts l }
# outputs:
# “[‘L’, 0]”
# “[‘R’, 1]”
# ...

23. What practical use is a
fiber?

24. Detour.do {|d| talk << 4}
# Non Evented
open('http://lrug.org/').read #=> ‘<html....
# Evented
class HTTPClient
def receive_body(data)
@data << data
end
end
http_client = HTTPClient.new
EventMachine::run do
EventMachine::connect 'lrug.org', 80, http_client
end
http_client.data #=> ‘<html....

25. So…what is a practical
use for a fiber?
http://www.espace.com.eg/neverblock/

26. What I didn’t say
• The rest of the API
• fiber_instance.transfer - invoke on a Fiber to pass
control to it, instead of yielding to the caller
• fiber_instance.alive? - can we safely resume this
Fiber, or has it terminated?
• Fiber.current - get the current Fiber so we can play
with it
• Lightweight - less memory over head than threads
• The downsides - single core only really

27. It’s over!
Thanks for listening, any questions?

28. Resources
• http://delicious.com/hlame/fibers
• (most of the stuff I researched is here)
• http://github.com/oldmoe/neverblock
• http://en.wikipedia.org/wiki/Fiber_(computer_science)
• http://en.wikipedia.org/wiki/Coroutine