92% found this document useful (13 votes)

25K views

Garbage Collection and The Ruby Heap

This document discusses garbage collection in Ruby. It begins by explaining that Ruby uses garbage collection to manage memory, eliminating the need for manual memory management. It then contrasts Ruby code with C code to show how Ruby avoids issues like memory leaks through garbage collection. The rest of the document dives into the technical details of how garbage collection works in Ruby, including how objects are allocated on the heap, how a freelist is used to track unused objects, and how garbage collection reclaims unused memory by adding objects to the freelist. It describes how Ruby objects on the heap have a fixed size and structure, and can represent different types of Ruby objects.

Uploaded by

Aman Gupta

Available Formats

Download as PDF, TXT or read online on Scribd

92% found this document useful (13 votes)

25K views

Garbage Collection and The Ruby Heap

Uploaded by

Aman Gupta

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 70

Garbage Collection and the

Ruby Heap
Joe Damato and Aman Gupta
@joedamato @tmm1
About Joe Damato
CMU/VMWare alum
memprof, ltrace-libdl, performance
improvements to REE
http://timetobleed.com
@joedamato
About Aman Gupta
San Francisco, CA
Ruby Hero 2009
EventMachine, amqp, REE, sinbook,
perftools.rb, gdb.rb
github.com/tmm1
@tmm1
Why Garbage Collection?
We use Ruby because it’s simple and elegant
the GC is designed to make your life easier
how is it easier? no more:
memory management
memory leaks

not convinced? let’s look at some C code...

C code vs Ruby code
void func() {
char *stack = "hello";
char *heap = malloc(6); def func
strncpy(heap, "world", 5); local = "hello"
free(heap); @instance = "world"
} end

memory explicitly allocated no concept of stack

on either the stack or the allocated variables
heap
even local variables
local variables usually live live on the heap
on the stack
no way to explicitly
heap allocated memory free memory
must be free()d or it will leak
Recap: Stack vs Heap

bytes on stack bytes on heap

Recap: Stack vs Heap

func1()
4 bytes void *data;
func2();

bytes on stack bytes on heap

Recap: Stack vs Heap

func2()
4 bytes char *string = func3();
free(string);

func1()
4 bytes void *data;
func2();

bytes on stack bytes on heap

Recap: Stack vs Heap

char *func3()
char buffer[8];
12 bytes char *string = malloc(10);

return string;

func2()
4 bytes char *string = func3();
free(string);

func1()
4 bytes void *data;
func2();

bytes on stack bytes on heap

Recap: Stack vs Heap

char *func3()
char buffer[8];
12 bytes char *string = malloc(10); 10 bytes

return string;

func2()
4 bytes char *string = func3();
free(string);

func1()
4 bytes void *data;
func2();

bytes on stack bytes on heap

Recap: Stack vs Heap

10 bytes

func2()
4 bytes char *string = func3();
free(string);

func1()
4 bytes void *data;
func2();

bytes on stack bytes on heap

Recap: Stack vs Heap

func1()
4 bytes void *data;
func2();

bytes on stack bytes on heap

Ruby Objects (in MRI)
always allocated on the heap (even local variables)
fixed size structure
sizeof(struct RVALUE) = 40 bytes
“allocated” in gc.c’s rb_newobj()
“freed” in gc.c’s add_freelist() via garbage_collect()

let’s look at some code...

VALUE
rb_newobj()
rb_newobj creates a
{ new ruby object
VALUE obj;

if (during_gc)
rb_bug("allocation during GC");

if (!freelist) force GC if freelist is empty

garbage_collect();

obj = (VALUE)freelist; pull object off the freelist

freelist = freelist->as.free.next;
MEMZERO((void*)obj, RVALUE, 1);
return obj; return new object
}
VALUE
rb_newobj()
{
VALUE obj;

if (during_gc)
add_freelist frees an
rb_bug("allocation during GC"); existing object
if (!freelist)
garbage_collect();

obj = (VALUE)freelist;
freelist = freelist->as.free.next;
MEMZERO((void*)obj, RVALUE, 1);
return obj; static inline void
} add_freelist(p)
RVALUE *p;
{
p->as.free.flags = 0;
p->as.free.next = freelist;
add object to top of freelist freelist = p;
}
The Ruby heap
The Ruby heap sort of resembles a slab allocator
Ruby allocates a slab by calling malloc
This space is carved up into fixed size slots for holding
Ruby objects
You can get an unused object from the Ruby heap by
calling rb_newobj
If there are no objects available, GC is run
If there are still no objects available, another slab is
created
Heaps on top of heaps
The Freelist
rb_newobj() tries to pull a free
slot off the freelist