RailsConf 2014 presentation

1. Improve Performance Quick and Cheap:
Optimize Memory and Upgrade to Ruby 2.1
http://www.slideshare.net/adymo/adymo-railsconf-improveperformance

2. Part 1
Why?

3. Memory optimization is the #1 thing that
makes your Ruby application fast

4. Memory overhead
+
Slow GC algorithm
=

5. Memory overhead
+
Slow GC algorithm
=
High memory consumption
+
Enormous time spent in GC

6. 2010 2011 2012 2013 2014
0
5
10
15
20
25
Requests(millions)
Memory Optimized Rails App (Ruby 1.8)
Same $1k/mo hardware all these years

7. Rails App Upgraded from Ruby 1.9 to 2.1
Compare before/after

8. Optimize Memory and
Optionally
Upgrade to Ruby 2.1

9. require "csv"
data = CSV.open("data.csv")
output = data.readlines.map do |line|
line.map do |col|
col.downcase.gsub(/b('?[a-z])/) { $1.capitalize } }
end
end
File.open("output.csv", "w+") do |f|
f.write output.join("n")
end
Unoptimized Program

10. Ruby 1.9 & 2.0
Ruby 2.1
0 5 10 15 20 25
Ruby 2.1 Is 40% Faster, Right?

11. require "csv"
output = File.open("output.csv", "w+")
CSV.open("examples/data.csv", "r").each do |line|
output.puts line.map do |col|
col.downcase!
col.gsub!(/b('?[a-z])/) { $1.capitalize! }
end.join(",")
end
Memory Optimized Program

12. Ruby 2.1 Is NOT Faster
...once your program is memory optimized
Ruby 1.9 & 2.0
Ruby 2.1
0 2 4 6 8 10 12 14

13. Takeaways
1. Ruby 2.1 is not a silver performance bullet
2. Memory optimized Ruby app performs the same in 1.9, 2.0 and 2.1
3. Ruby 2.1 merely makes performance adequate by default
4. Optimize memory to make a difference

14. Part 2
How?

15. 5 Memory Optimization Strategies
1. Tune garbage collector
2. Do not allow Ruby instance to grow
3. Control GC manually
4. Write less Ruby
5. Avoid memory-intensive Ruby and Rails features

16. Strategy 1
Tune Ruby GC

17. Ruby GC Tuning Goal
Goal: balance the number of GC runs and peak memory usage
How to check:
> GC.stat[:minor_gc_count]
> GC.stat[:major_gc_count]
> `ps -o rss= -p #{Process.pid}`.chomp.to_i / 1024 #MB

18. When Is Ruby GC Triggered?
Minor GC (faster, only new objects collected):
- not enough space on the Ruby heap to allocate new objects
- every 16MB-32MB of memory allocated in new objects
Major GC (slower, all objects collected):
- number of old or shady objects increases more than 2x
- every 16MB-128MB of memory allocated in old objects

19. Environment Variables
Initial number of slots on the heap RUBY_GC_HEAP_INIT_SLOTS 1000
Min number of slots that GC must free RUBY_GC_HEAP_FREE_SLOTS 4096
Heap growth factor RUBY_GC_HEAP_GROWTH_FACTOR 1.8
Maximum heap slots to add RUBY_GC_HEAP_GROWTH_MAX_SLOTS -
New generation malloc limit RUBY_GC_MALLOC_LIMIT 16M
Maximum new generation malloc limit RUBY_GC_MALLOC_LIMIT_MAX 32M
New generation malloc growth factor RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR 1.4
Old generation malloc limit RUBY_GC_OLDMALLOC_LIMIT 16M
Maximum old generation malloc limit RUBY_GC_OLDMALLOC_LIMIT_MAX 128M
Old generation malloc growth factor RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR 1.2

20. When Is Ruby GC Triggered?
ruby-performance-book.com
http://samsaffron.com/archive/2013/11/22/demystifying-the-ruby-gc
http://thorstenball.com/blog/2014/03/12/watching-understanding-ruby-2.1-garbage-collector/

21. Strategy 2
Limit Growth

22. 3 Layers of Memory Consumption Control
1. Internal
read `ps -o rss= -p #{Process.pid}`.chomp.to_i / 1024
or VmRSS from/proc/pid/#{Process.pid}
and exit worker

23. 3 Layers of Memory Consumption Control
1. Internal
read `ps -o rss= -p #{Process.pid}`.chomp.to_i / 1024
or VmRSS from/proc/pid/#{Process.pid}
and exit worker

24. 3 Layers of Memory Consumption Control
2. External (software)
Heroku, Monit, God, etc.

25. 3 Layers of Memory Consumption Control
3. External (OS kernel)
Process.setrlimit(Process::RLIMIT_AS, <N bytes>)

26. What about Background Jobs?
Fork et Impera:
# setup background job
fork do
# do something heavy
end

27. Strategy 3
Control GC Manually

28. GC Between Requests in Unicorn
OobGC for Ruby < 2.1
require 'unicorn/oob_gc'
use(Unicorn::OobGC, 1)
gctools for Ruby >= 2.1 https://github.com/tmm1/gctools
require 'gctools/oobgc'
use(GC::OOB::UnicornMiddleware)

29. GC Between Requests in Unicorn
Things to have in mind:
- make sure you have enough workers
- make sure CPU utilization < 50%
- this improves only “perceived” performance
- overall performance might be worse
- only effective for memory-intensive applications

30. Strategy 4
Write Less Ruby

31. Example: Group Rank
SELECT * FROM empsalary;
depname | empno | salary
-----------+-------+-------
develop | 6 | 6000
develop | 7 | 4500
develop | 5 | 4200
personnel | 2 | 3900
personnel | 4 | 3500
sales | 1 | 5000
sales | 3 | 4800

32. PostgreSQL Window Functions
SELECT depname, empno, salary, rank()
OVER (PARTITION BY depname ORDER BY salary DESC)
FROM empsalary;
depname | empno | salary | rank
-----------+-------+--------+------
develop | 6 | 6000 | 1
develop | 7 | 4500 | 2
develop | 5 | 4200 | 3
personnel | 2 | 3900 | 1
personnel | 4 | 3500 | 2
sales | 1 | 5000 | 1
sales | 3 | 4800 | 2

33. Finally Learn SQL

34. Strategy 5
Avoid Memory Hogs

35. Operations That Copy Data
● String::gsub! instead of String::gsub and similar
● String::<< instead of String::+=
● File::readline or File::each instead of File::readlines or File.read
● CSV::parseline instead of CSV::parse

36. ActiveRecord Also Copies Data
● ActiveRecord::Base::update_all
Book.where('title LIKE ?', '%Rails%').
order(:created_at).limit(5).
update_all(author: 'David')
● Direct manipulation over query result
result = ActiveRecord::Base.execute 'select * from books'
result.each do |row|
# do something with row.values_at('col1', 'col2')
end

37. Rails Serializers Copy Too Much
class Smth < ActiveRecord::Base
serialize :data, JSON
end
class Smth < ActiveRecord::Base
def data
JSON.parse(read_attribute(:data))
end
def data=(value)
write_attribute(:data, value.to_json)
end
end

38. Part 3
Tools

39. GC.stat
=>{
:count=>11,
:minor_gc_count=>8,
:major_gc_count=>3,
:heap_used=>126,
:heap_length=>130,
:malloc_increase=>7848,
:malloc_limit=>16777216,
:oldmalloc_increase=>8296,
:oldmalloc_limit=>16777216
}

40. objspace.so
> ObjectSpace.count_objects
=> {:TOTAL=>51359, :FREE=>16314, :T_OBJECT=>1356 ...
> require 'objspace'
> ObjectSpace.memsize_of(Class)
=> 1096
> ObjectSpace.reachable_objects_from(Class)
=> [#<InternalObject:0x007f87acf06e10 T_CLASS>, Class...
> ObjectSpace.trace_object_allocations_start
> str = "x" * 1024 * 1024 * 10
> ObjectSpace.allocation_generation(str)
=> 11

41. objspace.so
http://tmm1.net/ruby21-objspace/
http://stackoverflow.com/q/20956401
GC.stat
http://samsaffron.com/archive/2013/11/22/demystifying-the-ruby-gc

42. RubyProf Memory Profiling
require 'ruby-prof'
RubyProf.measure_mode = RubyProf::MEMORY
RubyProf.start
str = 'x'*1024*1024*10
result = RubyProf.stop
printer = RubyProf::FlatPrinter.new(result)
printer.print(STDOUT)
This requires patched Ruby, will work only for 1.8 and 1.9
https://github.com/ruby-prof/ruby-prof/issues/86

43. Valgrind Memory Profiling
> valgrind --tool=massif `rbenv which irb`
==9395== Massif, a heap profiler
irb(main):001:0> x = "x"*1024*1024*10; nil
=> nil
==9395==
> ms_print massif.out.9395
> massif-visualizer massif.out.9395
http://valgrind.org
https://projects.kde.org/projects/extragear/sdk/massif-visualizer

45. http://www.slideshare.net/adymo/adymo-railsconf-improveperformance
Sign up for my upcoming book updates:
ruby-performance-book.com
Ask me:
alex@alexdymo.com
@alexander_dymo
AirPair with me:
airpair.me/adymo