1. Ruby Memory Model
Hari Krishnan
@harikrishnan83

2. Why this talk?

3. Memory model is not
about

6. A quick exercise

9. Increment operation is not a single
instruction
● Retrieve the current value of @count.
● Increment the retrieved value by 1.
● Store the incremented value back in
@count.

10. Thread A Thread B
@count = 0Load @count = 0
Increment
Store
Load
Increment
Store
@count = 1
@count = 2
@count = 1

11. Thread A Thread B
@count = 0Load @count = 0
Increment
Store
Load
Increment
Store@count = 1

12. Where does reordering happen
Core 1
Cache
Core 2
Cache
Compiler
Memory

13. What is a memory model?
A memory model describes the interactions of threads through memory
and their shared use of the data

14. Atomicity

15. Visibility

16. Ordering

17. Should rubyists care
about this?
Ruby is single threaded

18. Are single threaded
languages like Ruby
thread safe?

19. Does single core imply
thread safe?

20. Concurrency is about Interleavings
Thread A - Load
Thread A - Increment
Thread B - Load
Thread A - Store
Thread B - Increment
Thread B - Store

21. Threading in Ruby

22. How is Ruby made Single Threaded
● 1.8 - Green Threads - Global Interpreter
Lock
● 1.9 - OS Threads - Global VM Lock

23. Does GIL make you
thread safe?

24. How does GIL work?
Ruby Thread 1 Ruby Thread 2
OS Thread 1 OS 2
Timer Thread
Wake up!Interrupt

25. GIL Details
● GIL is acquired at start of Thread block and
released once done
● To ensure fairness a timer thread sends an
interrupt to the Thread holding GIL when
other threads are waiting
● The Thread holding GIL may choose to
release it based on many parameters
Refer to this excellent blog post by Jesse Storimer - http://www.jstorimer.com/blogs/workingwithcode/8085491-
nobody-understands-the-gil

26. Now do you still think it is
thread safe?

27. Never depend on GIL for Thread
Safety
● GIL does not have a specification
● It also ties us to MRI
● Rubinius and JRuby do not have GIL

28. Ruby does not have a
documented Memory
Model

29. Ruby right now depends on
underlying Virtual Machines
● MRI is not much of an interpreter. It is a VM.
- No specification for Memory Model
● JRuby - JVM - JSR 133
● Rubinius - LLVM for JIT -

30. What do we do?

31. Start Engineering Code
for Thread Safety

33. Do not leave innocent
accessors lying around

34. Methods that mutate
parameters are generally
dangerous

35. Gems to the rescue
● atomic - https://github.com/headius/ruby-
atomic
● thread_safe - https://github.
com/headius/thread_safe

36. Thank you!
Hari Krishnan
@harikrishnan83