Digesting MRI by Studying Alternative Ruby Implementations

Efa305e8e1b4eca01dd9f5c8bea4294b?s=47 Christian Bruckmayer
September 23, 2019
5

Digesting MRI by Studying Alternative Ruby Implementations

Pointers, managing memory and static typing - writing C code is hard! However, most programming languages, including Matz's Ruby Interpreter (MRI), are implemented in a low level programming language. So you think without knowing these concepts, you can not contribute to Ruby? Wrong! Although MRI is implemented in C, fortunately there are Ruby's in Java, Go and even Ruby itself.

If you ever wanted to learn about Ruby internals without being a C expert, this talk is for you. Join me on my journey of re-implementing hash maps in JRuby, breaking bundler and actually learn to write (some) C code.

Efa305e8e1b4eca01dd9f5c8bea4294b?s=128

Christian Bruckmayer

September 23, 2019
Tweet

Transcript

  1. What defines a “Senior Developer”?

  2. Experience

  3. Leadership

  4. Mentor

  5. Communication

  6. “Masters” Programming

  7. “Masters” Ruby

  8. Digesting MRI by Studying Alternative Ruby Implementations

  9. Hello! I am 
 Christian Bruckmayer
 
 @bruckmayer
 bruckmayer.net

  10. Bristol

  11. None
  12. MRI Rubinius / Opal JRuby

  13. MRI / CRuby 1993 Programming language: C Known for: Reference

    implementation, Matz
  14. “Masters” Ruby

  15. Ruby is a computer program

  16. None
  17. None
  18. array = [1,2,3,4,5,6,7,8,9] # => [1, 2, 3, 4, 5,

    6, 7, 8, 9] puts array.minmax # => [1, 9] puts [array.min, array.max] # => [1, 9]
  19. require 'benchmark-driver' Benchmark.driver do |x| x.prelude <<~RUBY arr = (1..1000).map

    { rand } RUBY x.report %{ arr.minmax } x.report %{ [arr.min, arr.max] } end
  20. Warming up -------------------------------------- arr.minmax 36.970k i/s - 40.436k times in

    1.093742s (27.05μs/i) [arr.min, arr.max] 67.366k i/s - 72.435k times in 1.075249s (14.84μs/i) Calculating ------------------------------------- arr.minmax 36.784k i/s - 110.910k times in 3.015196s (27.19μs/i) [arr.min, arr.max] 67.324k i/s - 202.097k times in 3.001869s (14.85μs/i) Comparison: [arr.min, arr.max] : 67323.7 i/s arr.minmax : 36783.7 i/s - 1.83x slower
  21. None
  22. None
  23. None
  24. Embrace Failure

  25. Challenged

  26. Inspired

  27. MRI Rubinius / Opal JRuby

  28. Rubinius 2006 Programming language: Ruby, C, C++ Known for: Implemented

    as much as possible in Ruby
  29. Opal 2010 Programming language: Java Script, Ruby Known for: Ruby

    to Java Script, Ruby in the Browser
  30. None
  31. puts "Hello Indonesia".delete_prefix("Hello ") # Indonesia

  32. def delete_prefix(prefix) prefix = Rubinius::Type.check_convert_type prefix, String, :to_str return self[prefix.size..-1]

    if self.start_with?(prefix) dup end Rubinius
  33. def delete_prefix(prefix) %x{ if (!prefix.$$is_string) { #{prefix = Opal.coerce_to(prefix, String,

    :to_str)} } if (self.slice(0, prefix.length) === prefix) { return self.$$cast(self.slice(prefix.length)); } else { return self; } } end Opal
  34. "foobar".delete_prefix(:foo) # TypeError (no implicit conversion of Symbol into String)

    :foo.to_s # "foo" :foo.to_str # NoMethodError (undefined method `to_str' for :foo:Symbol)
  35. def delete_prefix(prefix) prefix = Rubinius::Type.check_convert_type prefix, String, :to_str return self[prefix.size..-1]

    if self.start_with?(prefix) dup end Rubinius
  36. vs prefix = :Hello.to_s “Hello ID”.delete_prefix(prefix) class Prefix def to_str

    “Hello" end end “Hello ID”. delete_prefix(Prefix.new) Explicit Implicit
  37. class Path def to_str "/chris" end end puts "home" +

    Path.new # home/chris
  38. class Path def to_s "/chris" end end puts "home" +

    Path.new # Traceback (most recent call last): # `+': no implicit conversion of Path into String (TypeError)
  39. None
  40. Three Lines of Code

  41. Implicit vs. Explicit

  42. MRI Rubinius / Opal JRuby

  43. JRuby 2001 Programming language: Java Known for: JVM, Concurrency, Fast

  44. It aims to be a complete, correct and fast implementation

    of Ruby
  45. None
  46. 40 % Faster

  47. None
  48. Rubinius 2006 Programming language: Ruby, C, C++ Known for: Implemented

    as much as possible in Ruby
  49. None
  50. /* Find an entry with KEY in table TAB. Return

    non-zero if we found it. Set up *RESULT to the found table entry key. */ int st_get_key(st_table *tab, st_data_t key, st_data_t *result) { st_index_t bin; st_hash_t hash = do_hash(key, tab); rb_p(key); .... }
  51. make: *** [encdb.h] Error 1 make: *** Waiting for unfinished

    jobs.... ../ruby/tool/transform_mjit_header.rb:5: [BUG] Segmentation fault at 0x0000000000000093 ruby 2.7.0dev (2019-09-03T19:17:53Z implement-ary-minmax ebebc4b80d) [x86_64-darwin18] -- Crash Report log information -------------------------------------------- See Crash Report log file under the one of following: * ~/Library/Logs/DiagnosticReports * /Library/Logs/DiagnosticReports for more details. Don't forget to include the above Crash Report log file in bug reports.
  52. None
  53. hash = {} hash[:key] = “value" hash[:key] # "value"

  54. class Hash def initialize @bins = Array.new(7) { [] }

    end private attr_reader :bins end Separate Chaining
  55. class Hash def initialize @bins = Array.new(7) { [] }

    end private attr_reader :bins end Separate Chaining
  56. def bin(key) bins[index(key)] end def index(key) key.hash % bins.length end

    Separate Chaining
  57. def find(key) bin(key).find do |entry| entry.key == key end end

    Separate Chaining
  58. def []=(key, value) if find(key) find(key).value = value else bin(key)

    << Entry.new(key, value) end end class Entry < Struct.new(:key, :value) end Separate Chaining
  59. Cache Locality

  60. If a particular storage location is referenced […], then it

    is likely that nearby memory locations will be referenced in the near future. Wikipedia
  61. [1,2,3,4,5,6,7,8,9].each do |i| puts i end

  62. class Hash def initialize @bins = Array.new(7) { [] }

    end private attr_reader :bins end Separate Chaining
  63. def bin(key) index = index(key) entry = bins[index] while entry

    != nil && entry.key != key index += 1 entry = bins[index] end index end Open Addressing
  64. def []=(key, value) if find(key) find(key).value = value else bins[bin(key)]

    = Entry.new(key, value) end end Open Addressing
  65. None
  66. Refactoring

  67. The Pragmatic Programmer “Different languages solve the same problems in

    different ways”
  68. Release Early, Release Often

  69. def []=(key, value) if find(key) find(key).value = value else bins[bin(key)]

    = Entry.new(key, value) end end Open Addressing
  70. def []=(key, value) if find(key) find(key).value = value else index

    = bin(key) bins[index] = key bins[index + 1] = value end end Open Addressing
  71. None
  72. None
  73. 2 months

  74. +682 LOC - 426 LOC

  75. None
  76. None
  77. Start Small

  78. Ask for Help

  79. MRI Rubinius / Opal JRuby

  80. Community

  81. Broaden your Horizon

  82. Thank You!
 
 @bruckmayer
 bruckmayer.net