640K ought to be enough for anybody, or how to use less memory in Ruby.

Ought 640K to be enough for anybody? Well, today we can use dozens of RAM, and it does not matter if our applications take up a few gigabytes. Right?

Have you ever been curious about why they use so much? Let's talk about how Ruby memory works, how we can profile memory usage and what to do to use less memory.

Transcript

1. 640K ought to be enough for anybody, or how to use less memory in Ruby Julia Egorova, Back-end developer at JetRockets
2. Julia Egorova github.com/vankiru twitter.com/vankiru vk.com/vankiru
3. 640k outght to be enough for anybody. » « Bill Gates, 1981
4. I've said some stupid things and some wrong things, but not that. » « Bill Gates, 1996
5. How much is 640K?
6. How much is 640K?
7. How much is 640K?
8. What about Ruby?
9. What about Ruby? Framework Memory Ruby On Rails ~ 60MB Hanami ~ 50MB Sinatra ~ 16MB Roda ~ 15MB
10. What about Rails? Method Memory Rocket.find(1) ~ 650KB rocket.save ~ 100KB number_to_currency(100) ~ 11KB stylesheet_link_tag("rocket.css") ~ 3Kb
11. How does Ruby memory work?
12. Garbage Collection
13. Garbage Collection Mark and Sweep
14. Free List
15. Free List
16. Free List
17. Free List
18. Mark Phase
19. Mark Phase
20. Mark Phase
21. Mark Phase
22. Mark Phase
23. Mark Phase
24. Sweep Phase
25. Sweep Phase
26. Sweep Phase
27. Generational GC
28. Generational GC
29. Generational GC
30. Generational GC
31. Generational GC
32. Generational GC
33. Generational GC
34. Generational GC
35. Generational GC
36. Generational GC
37. Generational GC
38. Generational GC
39. Ruby Memory Structure
40. Heap Pages and Slots
41. Heap Pages and Slots
42. Heap Pages and Slots
43. Heap Pages and Slots
44. Heap Pages and Slots
45. Heap Pages and Slots
46. Tiny, Small and Large Objects RValue
47. Tiny, Small and Large Objects VALUE *ptr → RValue
48. Tiny, Small and Large Objects VALUE *ptr → RValue typedef uintptr_t VALUE;
49. Tiny, Small and Large Objects
50. Tiny, Small and Large Objects
51. Tiny, Small and Large Objects
52. Tiny, Small and Large Objects
53. Tiny, Small and Large Objects
54. Tiny, Small and Large Objects
55. Tiny, Small and Large Objects
56. Tiny, Small and Large Objects
57. Tiny, Small and Large Objects
58. Tiny, Small and Large Objects
59. Tiny, Small and Large Objects
60. Tiny, Small and Large Objects
61. Tiny, Small and Large Objects
62. How to profile memory usage?
63. Ruby Memory Profiling GC ObjectSpace memory_profiler get_process_mem derailed_benchmarks • • • • •
64. GC.stat > GC.stat => { :count=>62, :heap_allocated_pages=>1416, :heap_available_slots=>577147, :heap_live_slots=>567649, :heap_free_slots=>9498, :total_allocated_pages=>1416, :total_allocated_objects=>2165898, … }
65. ObjectSpace > ObjectSpace.count_objects => { :TOTAL=>577147, :FREE=>9441, :T_OBJECT=>43380, :T_CLASS=>10129, :T_MODULE=>1542, :T_FLOAT=>9, :T_STRING=>272473, … }
66. ObjectSpace require "objspace" > ObjectSpace.memsize_of("Saturn V") => 40 > ObjectSpace.memsize_of(10) => 0
67. rockets = [ "Saturn V", "N1", "Energia Buran", "Falcon Heavy" ] ObjectSpace.each_object(String) do |object| puts "#{object} – #{ObjectSpace.memsize_of(object)}" end => Saturn V – 40 N1 – 40 Energia Buran – 40 Falcon Heavy – 40
68. memory_profiler require 'memory_profiler' report = MemoryProfiler.report do Rocket.find(1) end report.pretty_print => Total allocated: 692569 bytes (8457 objects) Total retained: 46495 bytes (640 objects)
69. Total allocated: 692569 bytes (8457 objects) Total retained: 46495 bytes (640 objects) allocated memory by class ----------------------------------- 632937 String 37656 Array 8424 File 6624 Hash … allocated objects by class ----------------------------------- 7468 String 899 Array 23 Hash 16 Symbol …
70. get_process_mem require 'get_process_mem' memory = GetProcessMem.new memory.bytes #=> 138735616 memory.kb #=> 135488.0 memory.mb #=> 132.37891 memory.gb #=> 0.1293449
71. derailed_benchmarks $ bundle exec derailed bundle:mem TOP: 61.5313 MiB rails/all: 25.332 MiB rails: 11.7891 MiB slim: 1.6992 MiB slim/engine: 0.6016 MiB slim/parser: 0.3086 MiB dry-struct: 1.0508 MiB dry/struct: 1.0508 MiB
72. derailed_benchmarks $ bundle exec derailed bundle:objects Total allocated: 36578388 bytes (337639 objects) Total retained: 4555830 bytes (37728 objects) allocated memory by gem ----------------------------------- 28982982 activesupport-5.1.6.1 1030516 forwardable 980919 graphql-1.7.7
73. What to do next?
74. number_to_currency
75. Total allocated: 11044 bytes (110 objects) Total retained: 0 bytes (0 objects) allocated memory by class ----------------------------------- 5864 Hash 1792 String 1760 Array 1120 MatchData 180 BigDecimal allocated objects by class ----------------------------------- 36 Array 32 String 29 Hash 4 MatchData 2 BigDecimal
76. ActiveSupport::NumberHelper NumberToCurrencyConverter NumberToDelimitedConverter NumberToHumanConverter NumberToHumanSizeConverter NumberToPercentageConverter NumberToPhoneConverter NumberToRoundedConverter • • • • • • •
77. ActiveSupport::NumberHelper NumberToCurrencyConverter NumberToDelimitedConverter NumberToHumanConverter NumberToHumanSizeConverter NumberToPercentageConverter NumberToPhoneConverter NumberToRoundedConverter NumberConverter • • • • • • •
78. NumberConverter
79. # active_support/number_helper/number_converter.rb def options @options ||= format_options.merge(opts) end def format_options default_format_options.merge!(i18n_format_options) end def default_format_options options = DEFAULTS[:format].dup options.merge!(DEFAULTS[namespace][:format]) if namespace options end
80. @options ||= format_options.merge(opts) # active_support/number_helper/number_converter.rb def options end def format_options default_format_options.merge!(i18n_format_options) end def default_format_options options = DEFAULTS[:format].dup options.merge!(DEFAULTS[namespace][:format]) if namespace options end
81. @options ||= format_options.merge(opts) # active_support/number_helper/number_converter.rb def options end def format_options default_format_options.merge!(i18n_format_options) end def default_format_options options = DEFAULTS[:format].dup options.merge!(DEFAULTS[namespace][:format]) if namespace options end Class Objects Memory Hash 1 192 bytes
82. default_format_options.merge!(i18n_format_options) # active_support/number_helper/number_converter.rb def options @options ||= format_options.merge(opts) end def format_options end def default_format_options options = DEFAULTS[:format].dup options.merge!(DEFAULTS[namespace][:format]) if namespace options end Class Objects Memory Hash 1 192 bytes
83. options = DEFAULTS[:format].dup # active_support/number_helper/number_converter.rb def options @options ||= format_options.merge(opts) end def format_options default_format_options.merge!(i18n_format_options) end def default_format_options options.merge!(DEFAULTS[namespace][:format]) if namespace options end Class Objects Memory Hash 1 192 bytes
84. options = DEFAULTS[:format].dup # active_support/number_helper/number_converter.rb def options @options ||= format_options.merge(opts) end def format_options default_format_options.merge!(i18n_format_options) end def default_format_options options.merge!(DEFAULTS[namespace][:format]) if namespace options end Class Objects Memory Hash 2 (+1) 384 bytes (+192)
85. options.merge!(DEFAULTS[namespace][:format]) if namespace # active_support/number_helper/number_converter.rb def options @options ||= format_options.merge(opts) end def format_options default_format_options.merge!(i18n_format_options) end def default_format_options options = DEFAULTS[:format].dup options end Class Objects Memory Hash 2 384 bytes
86. # active_support/number_helper/number_converter.rb def i18n_format_options locale = opts[:locale] options = I18n.translate( :'number.format', locale: locale, default: {}).dup if namespace options.merge!(I18n.translate( :"number.#{namespace}.format", locale: locale, default: {})) end options end Class Objects Memory Hash 2 384 bytes
87. options = I18n.translate( :'number.format', locale: locale, default: {}).dup # active_support/number_helper/number_converter.rb def i18n_format_options locale = opts[:locale] if namespace options.merge!(I18n.translate( :"number.#{namespace}.format", locale: locale, default: {})) end options end Class Objects Memory Hash 2 384 bytes
88. options = I18n.translate( :'number.format', locale: locale, default: {}).dup # active_support/number_helper/number_converter.rb def i18n_format_options locale = opts[:locale] if namespace options.merge!(I18n.translate( :"number.#{namespace}.format", locale: locale, default: {})) end options end Class Objects Memory Hash 7 (+5) 1344 bytes (+960) Array 7 280 bytes
89. if namespace options.merge!(I18n.translate( :"number.#{namespace}.format", locale: locale, default: {})) end # active_support/number_helper/number_converter.rb def i18n_format_options locale = opts[:locale] options = I18n.translate( :'number.format', locale: locale, default: {}).dup options end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes
90. NumberToCurrencyConverter
91. # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] number = absolute_value(number) end rounded_number = NumberToRoundedConverter.convert(number, options) format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes
92. number = self.number.to_s.strip # active_support/number_helper/number_to_currency_converter.rb def convert format = options[:format] if number.to_f.negative? format = options[:negative_format] number = absolute_value(number) end rounded_number = NumberToRoundedConverter.convert(number, options) format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes
93. number = self.number.to_s.strip # active_support/number_helper/number_to_currency_converter.rb def convert format = options[:format] if number.to_f.negative? format = options[:negative_format] number = absolute_value(number) end rounded_number = NumberToRoundedConverter.convert(number, options) format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 2 80 bytes
94. number = absolute_value(number) # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] end rounded_number = NumberToRoundedConverter.convert(number, options) format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 2 80 bytes
95. number = absolute_value(number) def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] end rounded_number = NumberToRoundedConverter.convert(number, options) format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 2 80 bytes
96. number = absolute_value(number) def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] end rounded_number = NumberToRoundedConverter.convert(number, options) format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 4 (+2) 160 bytes (+80)
97. format.gsub("%n", rounded_number).gsub("%u", options[:unit]) # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] number = absolute_value(number) end rounded_number = NumberToRoundedConverter.convert(number, options) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 4 160 bytes
98. format.gsub("%n", rounded_number).gsub("%u", options[:unit]) # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] number = absolute_value(number) end rounded_number = NumberToRoundedConverter.convert(number, options) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 10 (+6) 400 bytes (+240)
99. rounded_number = NumberToRoundedConverter.convert(number, options) # active_support/number_helper/number_to_currency_converter.rb def convert number = self.number.to_s.strip format = options[:format] if number.to_f.negative? format = options[:negative_format] number = absolute_value(number) end format.gsub("%n", rounded_number).gsub("%u", options[:unit]) end def absolute_value(number) number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "") end Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 10 400 bytes
100. NumberToRoundedConverter
101. # active_support/number_helper/number_to_rounded_converter.rb def convert helper = RoundingHelper.new(options) rounded_number = helper.round(number) if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end … Class Objects Memory Hash 7 1344 bytes Array 7 280 bytes String 10 400 bytes
102. # active_support/number_helper/number_to_rounded_converter.rb def convert helper = RoundingHelper.new(options) rounded_number = helper.round(number) if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end … Class Objects Memory Hash 14 (+7) 2688 bytes (+1344) Array 14 (+7) 560 bytes (+280) String 10 400 bytes
103. helper = RoundingHelper.new(options) # active_support/number_helper/number_to_rounded_converter.rb def convert rounded_number = helper.round(number) if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end … Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes
104. helper = RoundingHelper.new(options) # active_support/number_helper/number_to_rounded_converter.rb def convert rounded_number = helper.round(number) if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end … Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes RoundingHelper 1 40 bytes
105. rounded_number = helper.round(number) # active_support/number_helper/number_to_rounded_converter.rb def convert helper = RoundingHelper.new(options) if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end … Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes RoundingHelper 1 40 bytes
106. rounded_number = helper.round(number) # active_support/number_helper/number_to_rounded_converter.rb def convert helper = RoundingHelper.new(options) if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end … Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
107. if precision = options[:precision] if options[:significant] && precision > 0 digits = helper.digit_count(rounded_number) precision -= digits precision = 0 if precision < 0 # don't let it be negative end # active_support/number_helper/number_to_rounded_converter.rb def convert helper = RoundingHelper.new(options) rounded_number = helper.round(number) … Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
108. # active_support/number_helper/number_to_rounded_converter.rb … formatted_string = if BigDecimal === rounded_number && rounded_number.finite? s = rounded_number.to_s("F") s << "0" * precision a, b = s.split(".", 2) a << "." a << b[0, precision] else "%00.#{precision}f" % rounded_number end else formatted_string = rounded_number end number = NumberToDelimitedConverter.convert(formatted_string, options) format_number(number) end Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
109. s = rounded_number.to_s("F") s << "0" * precision a, b = s.split(".", 2) a << "." a << b[0, precision] # active_support/number_helper/number_to_rounded_converter.rb … formatted_string = if BigDecimal === rounded_number && rounded_number.finite? else "%00.#{precision}f" % rounded_number end else formatted_string = rounded_number end number = NumberToDelimitedConverter.convert(formatted_string, options) format_number(number) end Class Objects Memory Hash 14 2688 bytes Array 14 560 bytes String 10 400 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
110. s = rounded_number.to_s("F") s << "0" * precision a, b = s.split(".", 2) a << "." a << b[0, precision] # active_support/number_helper/number_to_rounded_converter.rb … formatted_string = if BigDecimal === rounded_number && rounded_number.finite? else "%00.#{precision}f" % rounded_number end else formatted_string = rounded_number end number = NumberToDelimitedConverter.convert(formatted_string, options) format_number(number) end Class Objects Memory Hash 14 2688 bytes Array 15 (+1) 600 bytes (+40) String 15 (+5) 600 bytes (+200) RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
111. number = NumberToDelimitedConverter.convert(formatted_string, options) # active_support/number_helper/number_to_rounded_converter.rb … formatted_string = if BigDecimal === rounded_number && rounded_number.finite? s = rounded_number.to_s("F") s << "0" * precision a, b = s.split(".", 2) a << "." a << b[0, precision] else "%00.#{precision}f" % rounded_number end else formatted_string = rounded_number end format_number(number) end Class Objects Memory Hash 14 2688 bytes Array 15 600 bytes String 15 600 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
112. NumberToDelimitedConverter
113. # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 14 2688 bytes Array 15 600 bytes String 15 600 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
114. # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 21 (+7) 4032 bytes (+1344) Array 22 (+7) 880 bytes (+280) String 15 600 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
115. parts.join(options[:separator]) # active_support/number_helper/number_to_delimited_converter.rb def convert end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 22 880 bytes String 15 600 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
116. left, right = number.to_s.split(".") # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 22 880 bytes String 15 600 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
117. left, right = number.to_s.split(".") # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 23 (+1) 920 bytes (+40) String 17 (+2) 680 bytes (+80) RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
118. left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left, right = number.to_s.split(".") [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 23 920 bytes String 22 880 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes
119. left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left, right = number.to_s.split(".") [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 23 920 bytes String 30 (+8) 1200 bytes (+320) RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes
120. [left, right].compact # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end end Class Objects Memory Hash 21 4032 bytes Array 23 920 bytes String 30 1200 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes
121. [left, right].compact # active_support/number_helper/number_to_delimited_converter.rb def convert parts.join(options[:separator]) end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end end Class Objects Memory Hash 21 4032 bytes Array 25 (+2) 1000 bytes (+80) String 30 1200 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes
122. parts.join(options[:separator]) # active_support/number_helper/number_to_delimited_converter.rb def convert end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 25 1000 bytes String 30 1200 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes
123. parts.join(options[:separator]) # active_support/number_helper/number_to_delimited_converter.rb def convert end private def parts left, right = number.to_s.split(".") left.gsub!(delimiter_pattern) do |digit_to_delimit| "#{digit_to_delimit}#{options[:delimiter]}" end [left, right].compact end Class Objects Memory Hash 21 4032 bytes Array 25 1000 bytes String 31 (+1) 1240 bytes (+40) RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes
124. Class Objects Memory Hash 21 4032 bytes Array 25 1000 bytes String 31 1240 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes Total 82 7048 bytes
125. Class Objects Memory Hash 21 4032 bytes Array 25 1000 bytes String 31 1240 bytes RoundingHelper 1 40 bytes BigDecimal 2 176 bytes MatchData 2 560 bytes Total 82 7048 bytes
126. Lets make number_to_currency great again!
127. How to make number_to_currency great again?
128. What we learned
129. What we learned Do not repeat yourself; •
130. What we learned Do not repeat yourself; Do not create objects that you do not need; • •
131. What we learned Do not repeat yourself; Do not create objects that you do not need; Use bang methods to modify an object instead of creating a new one; • • •
132. What we learned Do not repeat yourself; Do not create objects that you do not need; Use bang methods to modify an object instead of creating a new one; Use methods like insert to modify a string instead of creating a new one; • • • •
133. What we learned Do not repeat yourself; Do not create objects that you do not need; Use bang methods to modify an object instead of creating a new one; Use methods like insert to modify a string instead of creating a new one; Think of an algorithm that does not use much memory. • • • • •
134. 97532.5734 → $ 97,532.57
135. 97532.5734 → $ 97,532.57 def number_to_currency(number, options)
136. 97532.5734 → $ 97,532.57 def number_to_currency(number, options)
137. 97532.5734 → $ 97,532.57 def number_to_currency(number, options) string = number_to_string(number, options)
138. 97532.5734 → $ 97,532.57 def number_to_currency(number, options) string = number_to_string(number, options) add_delimiters(string, number, options)
139. 97532.5734 → $ 97,532.57 def number_to_currency(number, options) string = number_to_string(number, options) add_delimiters(string, number, options) add_unit(string, number, options)
140. 97532.5734 → $ 97,532.57 def number_to_currency(number, options) string = number_to_string(number, options) add_delimiters(string, number, options) add_unit(string, number, options) string end
141. 97532.5734 → 97532.57 def number_to_string(number, options)
142. 97532.5734 → 97532.57 def number_to_string(number, options)
143. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s end
144. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s end
145. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s end
146. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s end
147. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s
148. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s
149. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".")
150. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".")
151. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".") fractional = string.size - dot_index - 1
152. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".") fractional = string.size - dot_index - 1
153. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".") fractional = string.size - dot_index - 1 zeros_to_add = options[:precision] - fractional
154. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".") fractional = string.size - dot_index - 1 zeros_to_add = options[:precision] - fractional
155. 97532.5734 → 97532.57 def number_to_string(number, options) string = number.round( options[:precision]).to_s dot_index = string.rindex(".") fractional = string.size - dot_index - 1 zeros_to_add = options[:precision] - fractional zeros_to_add.times do string.insert(-1, "0") end end
156. 97532.57 → 97,532.57 def add_delimiters(string, number, options)
157. 97532.57 → 97,532.57 def add_delimiters(string, number, options)
158. 97532.57 → 97,532.57 def add_delimiters(string, number, options)
159. 97532.57 → 97,532.57 def add_delimiters(string, number, options)
160. 97532.57 → 97,532.57 def add_delimiters(string, number, options)
161. 97532.57 → 97,532.57 def add_delimiters(string, number, options)
162. 97532.57 → 97,532.57 def add_delimiters(string, number, options) offset = number > 0 ? 0 : 1 index = -5 - options[:precision]
163. 97532.57 → 97,532.57 def add_delimiters(string, number, options) offset = number > 0 ? 0 : 1 index = -5 - options[:precision]
164. 97532.57 → 97,532.57 def add_delimiters(string, number, options) offset = number > 0 ? 0 : 1 index = -5 - options[:precision] while offset - index <= string.size do string.insert(index, ",") index -= 4 end end
165. 97,532.57 → $ 97,532.57 def add_unit(string, number, options)
166. 97,532.57 → $ 97,532.57 def add_unit(string, number, options)
167. 97,532.57 → $ 97,532.57 def add_unit(string, number, options)
168. 97,532.57 → $ 97,532.57 def add_unit(string, number, options)
169. 97,532.57 → $ 97,532.57 def add_unit(string, number, options) index = number > 0 ? 0 : 1
170. 97,532.57 → $ 97,532.57 def add_unit(string, number, options) index = number > 0 ? 0 : 1
171. 97,532.57 → $ 97,532.57 def add_unit(string, number, options) index = number > 0 ? 0 : 1 string.insert(index, " ") string.insert(index, options[:unit]) end
172. Memory report = MemoryProfiler.new do number_to_currency(97532.5734) end report.pretty_print => Total allocated: 40 bytes (1 objects) Total retained: 0 bytes (0 objects)
173. Comparison ActiveSupport FasterSupport Memory 11 044 bytes 40 bytes Objects 110 objects 1 object
174. 41.74x slower Performance Checking for BigDecimal Warming up -------------------------------------- ActiveSupport 874.000 i/100ms FasterSupport 30.613k i/100ms Calculating ------------------------------------- ActiveSupport 9.263k (± 5.2%) i/s - 46.322k in 5.015584s FasterSupport 386.647k (± 2.9%) i/s - 1.959M in 5.071773s Comparison: FasterSupport: 386647.3 i/s ActiveSupport: 9262.8 i/s -
175. In the real life application Report with 128 columns ✕ 1000 rows; 23 columns with number_to_currency. • •
176. In the real life application Report with 128 columns ✕ 1000 rows; 23 columns with number_to_currency. • • 1.2415% less memory
177. Was it worth it?
178. Well...
179. Beyond Ludicrous Speed
180. Beyond Ludicrous Speed
181. FasterSupport
182. Links jetrockets.pro github.com/jetrockets github.com/vankiru github.com/jetrockets/faster_support