Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Down the rb_newobj() Rabbit Hole

Chris Kelly
February 21, 2013

Down the rb_newobj() Rabbit Hole

Take a walk through the C internals from Foo.new through garbage collection in Ruby's MRI. We’ll explore the idiom and optimizations in the C source and leave you feeling comfortable to work in the code yourself. Once we arrive at the end of the rabbit hole, we’ll examine the garbage collection algorithms used in Ruby 1.8, 1.9 and 2.0.

Chris Kelly

February 21, 2013
Tweet

More Decks by Chris Kelly

Other Decks in Programming

Transcript

  1. 1 2 3 4 What are we talking about Navigating

    CRuby Object Creation Garbage Collection
  2. require_dependency 'unicorn/oob_gc' require_dependency 'unicorn/unicorn_slayer.rb' GC_FREQUENCY = 40 # Don't run

    GC during requests GC.disable # Run UnicornSlayer during every request use(UnicornSlayer::Oom, ((1_024 + Random.rand(512)) * 1_024), 1) # Run OOB GC every GC_FREQUENCY requests use Unicorn::OobGC, GC_FREQUENCY /* config.ru */ Out of Band GC
  3. What is GC? Garbage collector’s function is to find data

    object that are no longer in use and make their space available for reuse by the running program. An object is considered garbage if it is not reachable by the running program via a path of pointer traversal.
  4. ObjectSpace.count_objects => { :TOTAL => 14716, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 478, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 996, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  5. ObjectSpace.count_objects => { :TOTAL => 14716, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 478, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 996, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  6. ObjectSpace.count_objects => { :TOTAL => 14718, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 996, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  7. ObjectSpace.count_objects => { :TOTAL => 14718, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 996, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  8. ObjectSpace.count_objects => { :TOTAL => 14719, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  9. ObjectSpace.count_objects => { :TOTAL => 14719, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  10. #!/usr/local/ruby Foo = Class.new objs = [] 10000.times do |i|

    objs << Foo.new end Fill it with Objects
  11. ObjectSpace.count_objects => { :TOTAL => 24719, :FREE => 317, :T_OBJECT

    => 10008, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  12. #!/usr/local/ruby Foo = Class.new objs = [] 10000.times do |i|

    objs << Foo.new end ObjectSpace.garbage_collect Try Garbage Collect
  13. ObjectSpace.count_objects => { :TOTAL => 14716, :FREE => 317, :T_OBJECT

    => 10008, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  14. #!/usr/local/ruby Foo = Class.new objs = [] 10000.times do |i|

    objs << Foo.new end ObjectSpace.garbage_collect objs = [] Empty the Array
  15. ObjectSpace.count_objects => { :TOTAL => 14716, :FREE => 317, :T_OBJECT

    => 10008, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  16. #!/usr/local/ruby Foo = Class.new objs = [] 10000.times do |i|

    objs << Foo.new end ObjectSpace.garbage_collect objs = [] ObjectSpace.garbage_collect Try GC Again
  17. ObjectSpace.count_objects => { :TOTAL => 14719, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  18. ObjectSpace.count_objects => { :TOTAL => 14719, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 480, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  19. #!/usr/local/ruby Foo = Class.new objs = [] 10000.times do |i|

    objs << Foo.new end ObjectSpace.garbage_collect objs = [] ObjectSpace.garbage_collect Object.send(:remove_const, :Foo) ObjectSpace.garbage_collect Remove the Class
  20. ObjectSpace.count_objects => { :TOTAL => 14716, :FREE => 317, :T_OBJECT

    => 8, :T_CLASS => 478, :T_MODULE => 21, :T_FLOAT => 7, :T_STRING => 6314, :T_REGEXP => 24, :T_ARRAY => 997, :T_HASH => 14, :T_BIGNUM => 3, :T_FILE => 9, :T_DATA => 402, :T_MATCH => 104, :T_COMPLEX => 1, :T_NODE => 5993, :T_ICLASS => 19 }
  21. struct RBasic basic; struct RObject object; struct RClass klass; struct

    RFloat flonum; struct RString string; struct RArray array; struct RRegexp regexp; struct RHash hash; struct RData data; struct RTypedData typeddata; struct RStruct rstruct; struct RBignum bignum; struct RFile file; struct RNode node; struct RMatch match; struct RRational rational; struct RComplex complex; /* gc.c */ Object Types
  22. struct RBasic { VALUE flags; VALUE klass; }; struct RObject

    { struct RBasic basic; union { struct { long numiv; VALUE *ivptr; struct st_table *iv_index_tbl; } heap; VALUE ary[ROBJECT_EMBED_LEN_MAX]; } as; }; /* include/ruby/ruby.h */ RBasic and RObject
  23. struct RBasic { VALUE flags; VALUE klass; }; struct RObject

    { struct RBasic basic; union { struct { long numiv; VALUE *ivptr; struct st_table *iv_... } heap; VALUE ary[ROBJECT_EMBED_... } as; }; /* include/ruby/ruby.h */ VALUE numiv ivptr RObject RBasic flags klass
  24. struct RString { struct RBasic basic; union { struct {

    long len; char *ptr; union { long capa; VALUE shared; } aux; } heap; char ary[RSTRING_EMBED_LEN_MAX + 1]; } as; }; /* include/ruby/ruby.h */ RString Magic
  25. struct RString { struct RBasic basic; union { struct {

    long len; char *ptr; union { long capa; VALUE shared; } aux; } heap; char ary[RSTRING_EMBED_LEN_MAX + 1]; } as; }; /* include/ruby/ruby.h */ RString Magic
  26. struct RString { struct RBasic basic; union { struct {

    long len; char *ptr; union { long capa; VALUE shared; } aux; } heap; char ary[RSTRING_EMBED_LEN_MAX + 1]; } as; }; /* include/ruby/ruby.h */ RString Magic
  27. #define R_CAST(st) (struct st*) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RSTRING_PTR(str) \

    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ RSTRING(str)->as.ary : \ RSTRING(str)->as.heap.ptr) /* include/ruby/ruby.h */ RString Macros
  28. #define R_CAST(st) (struct st*) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RSTRING_PTR(str) \

    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ RSTRING(str)->as.ary : \ RSTRING(str)->as.heap.ptr) /* include/ruby/ruby.h */ RString Macros
  29. #define R_CAST(st) (struct st*) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RSTRING_PTR(str) \

    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ RSTRING(str)->as.ary : \ RSTRING(str)->as.heap.ptr) /* include/ruby/ruby.h */ RString Macros
  30. #define R_CAST(st) (struct st*) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RSTRING_PTR(str) \

    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ RSTRING(str)->as.ary : \ RSTRING(str)->as.heap.ptr) /* include/ruby/ruby.h */ RString Macros
  31. #define R_CAST(st) (struct st*) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RSTRING_PTR(str) \

    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ RSTRING(str)->as.ary : \ RSTRING(str)->as.heap.ptr) /* include/ruby/ruby.h */ RString Macros struct RString(str)->as.heap.prt
  32. Ruby Heaps Heap RObject RString RArray RBasic klass flags RBasic

    klass flags RBasic klass flags Ruby Heaps Memory Operating System Virtual Machine Heaps Slot Heaps Slot Heaps Slot Heaps Slot
  33. Class#new VALUE rb_class_new_instance(int argc, VALUE *argv, VALUE klass) { VALUE

    obj; obj = rb_obj_alloc(klass); rb_obj_call_init(obj, argc, argv); return obj; } /* object.c */
  34. VALUE rb_obj_alloc(VALUE klass) { VALUE obj; rb_alloc_func_t allocator; /* ...

    */ allocator = rb_get_alloc_func(klass); /* ... */ obj = (*allocator)(klass); /* ... */ return obj; } /* object.c */ Object Allocation
  35. rb_alloc_func_t rb_get_alloc_func(VALUE klass) { Check_Type(klass, T_CLASS); for (; klass; klass

    = RCLASS_SUPER(klass)) { rb_alloc_func_t allocator = RCLASS_EXT(klass)->allocator; if (allocator == UNDEF_ALLOC_FUNC) break; if (allocator) return allocator; } return 0; } /* vm_method.c */ Find Alloc Method
  36. void Init_Object(void) { /* ... */ rb_define_private_method(rb_cBasicObject, "initialize", rb_obj_dummy, 0);

    rb_define_alloc_func(rb_cBasicObject, rb_class_allocate_instance); rb_define_method(rb_cBasicObject, "==", rb_obj_equal, 1); rb_define_method(rb_cBasicObject, "equal?", rb_obj_equal, 1); rb_define_method(rb_cBasicObject, "!", rb_obj_not, 0); rb_define_method(rb_cBasicObject, "!=", rb_obj_not_equal, 1); /* ... */ } /* object.c */ Define Alloc Method
  37. VALUE rb_newobj_of(VALUE klass, VALUE flags) { VALUE obj; obj =

    newobj(klass, flags); OBJSETUP(obj, klass, flags); return obj; } /* gc.c */ Create Ruby Object
  38. Get Object Space static VALUE newobj(VALUE klass, VALUE flags) {

    rb_objspace_t *objspace = &rb_objspace; VALUE obj; /* gc.c */ static VALUE newobj(VALUE klass, VALUE flags { rb_objspace_t *objspace = & VALUE obj; if (UNLIKELY(during_gc)) { dont_gc = 1; during_gc = 0; rb_bug("object allocatio } if (UNLIKELY(ruby_gc_stress if (!garbage_collect(obj during_gc = 0; rb_memerror(); } } if (UNLIKELY(!has_free_obje if (!gc_prepare_free_obj during_gc = 0; rb_memerror(); } } obj = (VALUE)objspace->heap objspace->heap.free_slots-> if (objspace->heap.free_slo unlink_free_heap_slot(o } MEMZERO((void*)obj, RVALUE, #ifdef GC_DEBUG RANY(obj)->file = rb_source RANY(obj)->line = rb_source #endif objspace->total_allocated_o return obj; }
  39. if (UNLIKELY(ruby_gc_stress && !ruby_disable_gc_stress)) { if (!garbage_collect(objspace)) { during_gc =

    0; rb_memerror(); } } /* gc.c */ Try Garbage Collect static VALUE newobj(VALUE klass, VALUE flags { rb_objspace_t *objspace = & VALUE obj; if (UNLIKELY(during_gc)) { dont_gc = 1; during_gc = 0; rb_bug("object allocatio } if (UNLIKELY(ruby_gc_stress if (!garbage_collect(obj during_gc = 0; rb_memerror(); } } if (UNLIKELY(!has_free_obje if (!gc_prepare_free_obj during_gc = 0; rb_memerror(); } } obj = (VALUE)objspace->heap objspace->heap.free_slots-> if (objspace->heap.free_slo unlink_free_heap_slot(o } MEMZERO((void*)obj, RVALUE, #ifdef GC_DEBUG RANY(obj)->file = rb_source RANY(obj)->line = rb_source #endif objspace->total_allocated_o return obj; }
  40. obj = (VALUE)objspace->heap.free_slots->freelist; objspace->heap.free_slots->freelist = RANY(obj)->as.free.next; if (objspace->heap.free_slots->freelist == NULL)

    { unlink_free_heap_slot(objspace, objspace->heap.free_slots); } Get the Next Free Slot static VALUE newobj(VALUE klass, VALUE flags { rb_objspace_t *objspace = & VALUE obj; if (UNLIKELY(during_gc)) { dont_gc = 1; during_gc = 0; rb_bug("object allocatio } if (UNLIKELY(ruby_gc_stress if (!garbage_collect(obj during_gc = 0; rb_memerror(); } } if (UNLIKELY(!has_free_obje if (!gc_prepare_free_obj during_gc = 0; rb_memerror(); } } obj = (VALUE)objspace->heap objspace->heap.free_slots-> if (objspace->heap.free_slo unlink_free_heap_slot(o } MEMZERO((void*)obj, RVALUE, #ifdef GC_DEBUG RANY(obj)->file = rb_source RANY(obj)->line = rb_source #endif objspace->total_allocated_o return obj; }
  41. MEMZERO((void*)obj, RVALUE, 1); #ifdef GC_DEBUG RANY(obj)->file = rb_sourcefile(); RANY(obj)->line =

    rb_sourceline(); #endif objspace->total_allocated_object_num++; return obj; } /* gc.c */ Return the Object static VALUE newobj(VALUE klass, VALUE flags { rb_objspace_t *objspace = & VALUE obj; if (UNLIKELY(during_gc)) { dont_gc = 1; during_gc = 0; rb_bug("object allocatio } if (UNLIKELY(ruby_gc_stress if (!garbage_collect(obj during_gc = 0; rb_memerror(); } } if (UNLIKELY(!has_free_obje if (!gc_prepare_free_obj during_gc = 0; rb_memerror(); } } obj = (VALUE)objspace->heap objspace->heap.free_slots-> if (objspace->heap.free_slo unlink_free_heap_slot(o } MEMZERO((void*)obj, RVALUE, #ifdef GC_DEBUG RANY(obj)->file = rb_source RANY(obj)->line = rb_source #endif objspace->total_allocated_o return obj; }
  42. static int garbage_collect(rb_objspace_t *objspace) { if (GC_NOTIFY) printf("start garbage_collect()\n"); if

    (!heaps) { return FALSE; } if (!ready_to_gc(objspace)) { return TRUE } /* ... */ during_gc++; gc_marks(objspace); /* ... */ gc_sweep(objspace); /* ... */ if (GC_NOTIFY) printf("end garbage_collect()\n"); return TRUE; } /* gc.c */ Mark & Sweep
  43. #!/usr/local/ruby Foo = Class.new single = [] single << Foo.new

    objs = [] 10000.times do |i| objs << Foo.new end Create Objects
  44. Root Heap *Foo *single RClass RArray RObject *objs RArray RObject

    RObject RObject RObject RObject RObje ROb ROb RObject Object Allocation
  45. Heap RObject RString RArray RBasic klass flags RBasic klass flags

    RBasic klass flags FL_MARK FL_MARK FL_MARK Object Anatomy
  46. #!/usr/local/ruby Foo = Class.new single = [] single << Foo.new

    objs = [] 10000.times do |i| objs << Foo.new end objs = nil Create Garbage
  47. Root Heap *Foo *single RClass RArray RObject *objs RArray RObject

    RObject RObject RObject RObject RObje ROb ROb RObject Object Allocation
  48. Root Heap *Foo *single RClass RArray RObject *objs RArray RObject

    RObject RObject RObject RObject RObje ROb ROb RObject Object Allocation ✔ ✔ ✔
  49. Traverse every object in the object space. Those with a

    mark are unmarked. Those that are already unmarked are added to the free set. Sweep Phase
  50. Sweep only in the case that there aren’t any free

    objects and the heap cannot be increased. Lazy Sweep
  51. When a process is forked, memory is shared. Memory is

    copied only when it is changed. Marking an object is considered changing it. Copy-on-Write
  52. Ruby 2.0 introduces a new type of garbage collection. FL_MARK

    flag has been moved to a bitmap memory structure. Bitmap Marking
  53. Significant work has been done on GC. Method cache changes

    are coming. People are getting involved. MRI’s Slow?
  54. Uniprocessor GC Techniques, Paul Wilson https://ritdml.rit.edu/bitstream/handle/1850/5112/PWilsonProceedings1992.pdf Rare are GC Talks,

    nari http://furious-waterfall-55.heroku.com/ruby-guide/internals/gc.html The Garbage Collection Handbook, Jones, Hosking, Moss http://gchandbook.org The Ruby Hacker’s Guide, Minero Aoki http://edwinmeyer.com/Integrated_RHG.html Ruby Under a Microscope, Pat Shaughnessy http://patshaughnessy.net/ruby-under-a-microscope C Programming Language, Brian Kernighan http://www.informit.com/store/c-programming-language-9780133086225 Learn More