Ruby Internals

RUBY INTERNALS
Use the source, Luke!

TW: @burkelibbey GH: @burke

TOPICS
• Basic object structure

• Class inheritance

• Singleton classes

• Module inheritance

• Contexts

struct RBasic {
VALUE flags;
VALUE klass;
};

Every object in ruby has an instance of RBasic.

struct RBasic {
VALUE flags;
VALUE klass;
};

ﬂags stores information like whether the object is
frozen, or tainted, or others.

struct RBasic {
VALUE flags;
VALUE klass;
};

klass is a pointer to the parent class
(or singleton class)

typedef uintptr_t VALUE;

VALUE is used like a void pointer in ruby C code.

struct RFloat {
struct RBasic basic;
double float_value;
};

This is a ﬂoat.

struct RFloat {
double float_value;
};

Like everything else, it has an RBasic.

struct RFloat {
double float_value;
};

...and also the actual ﬂoating point value.

#define ROBJECT_EMBED_LEN_MAX 3
struct RObject {
  union {
    struct {
      long numiv;
      VALUE *ivptr;
      struct st_table *iv_index_tbl;
    } heap;
    VALUE ary[ROBJECT_EMBED_LEN_MAX];
  } as;
};

This is a generic Object.

struct RObject {
  union {
    struct {
      long numiv;
      VALUE *ivptr;
    } heap;
  } as;
};

You can pretty much ignore this stuff.

struct RObject {
  union {
    struct {
      long numiv;
      VALUE *ivptr;
    } heap;
  } as;
};

Again, it has an RBasic representing its class (klass)
and internal attributes (ﬂags).

struct RObject {
  union {
    struct {
      long numiv;
      VALUE *ivptr;
    } heap;
  } as;
};

It also has instance variables.

long numiv;
VALUE *ivptr;

ivptr points to an array of ivar values.

long numiv;
VALUE *ivptr;

Unsurprisingly, numiv is the number of ivars.

long numiv;
VALUE *ivptr;

iv_index_tbl is essentially a hash of
{name -> index into ivptr}

long numiv;
VALUE *ivptr;

st_table is a C hashtable implementation.
It’s also the underpinning for ruby hashes.

struct RObject {
  union {
    struct {
      long numiv;
      VALUE *ivptr;
    } heap;
  } as;
};

Back to the top

An Object has:

• klass (parent class)

• ﬂags (frozen? tainted? etc.)

• Instance variables

• Nothing else.

We saw that Float has a distinct implementation
from Object

String, Regexp, Array, Hash, File, Rational, Complex,
Data, and Bignum do too.

These are mostly for performance reasons.

Class is the other exception.

Not just for performance. It has a lot of extra behaviour.

struct RClass {
    rb_classext_t *ptr;
    struct st_table *m_tbl;
};

struct RClass {
    rb_classext_t *ptr;
};

A class has attributes (ﬂags) and a class (klass).

struct RClass {
    rb_classext_t *ptr;
};

rb_classext_t stores more class-speciﬁc info

struct RClass {
    rb_classext_t *ptr;
};

m_tbl is a hash of methods. Think of it as:
{name -> method body}

struct RClass {
    rb_classext_t *ptr;
};

Just like iv_index_tbl on RObject, except the rest
of the ivar storage is done in rb_classext_t.

struct rb_classext_struct {
    VALUE super;
    struct st_table *iv_tbl;
    struct st_table *const_tbl;
};
typedef struct rb_classext_struct
rb_classext_t;

This is the extended class information.

    VALUE super;
};
rb_classext_t;

‘super’ is a pointer to the class’s superclass.

    VALUE super;
};
rb_classext_t;

iv_tbl is a hash of {ivar name -> ivar value}

    VALUE super;
};
rb_classext_t;

similarly, const_tbl stores constants as
{const name -> const value}

struct RClass {
    VALUE flags; // attributes
    VALUE klass; // parent class (often Class)
    VALUE super; // superclass (often Object)
    struct st_table *iv_tbl; // ivars
    struct st_table *const_tbl; // constants
    struct st_table *m_tbl; // methods
    struct st_table *iv_index_tbl; // ivars
};

An incorrect but helpful simpliﬁcation of RClass.

Let’s look at an example class and its RClass

class Oban < Scotch
  AGE = 14
  @tasty = true
  def tasty
    Oban.instance_variable_get("@tasty")
  end
end

class Oban < Scotch
  AGE = 14
  @tasty = true
  def tasty
    Oban.instance_variable_get("@tasty")
  end
end

basic.klass Class
ptr->super Scotch
iv_tbl {“@tasty” => true}
const_tbl {“AGE” => 14}
m_tbl {“tasty” => ...}

Another:

class Animal ; end

class Dog < Animal ; end

Let’s look at another class:

class Scotch < Liquor
  def tasty?
    true
  end
end

  def tasty?
    true
  end
end

This lets us call: Scotch.new.tasty?

  def tasty?
    true
  end
end

This lets us call: Scotch.new.tasty?
And puts {“tasty?” -> ...} into the m_tbl

  def tasty?
    true
  end
end

What if we wanted ‘tasty?’ to be a class
method?

It clearly works, but how does ruby know it’s
a class method?

  def self.tasty?
    true
  end
end

There’s only one m_tbl.

When you deﬁne a method with
“def self.(name)”, you create a singleton class.

‘self ’ is not everything it appears to be.

class Foo
  # self == Foo
  def bar
  end
end

‘bar’ is deﬁned as an instance method of ‘Foo’

class Foo
  def bar
  end
  def self.bar
  end
end

These should be the same, right?

class Foo
  def bar
  end
  def self.bar
  end
end

...because these are the same:
my_method
self.my_method

class Foo
  def bar
  end
  def self.bar
  end
end

Invocations use ‘self ’ if no receiver is given.
Don’t deﬁnitions? O_o

def foo Defines on the default definee

def target.bar Defines on target.singleton_class

ie: There’s a second, hidden context.

default_definee

default_definee
Target for method deﬁnitions
with no target

self
Receiver for method
invocations with no receiver

No easy way to reference the default deﬁnee.

eval "def _d;end"
y = method(:_d).owner rescue instance_method(:_d).owner
eval "undef _d"
y

This is ugly, but it works.

DEFINEE = 'eval "def _d;end";y = method(:_d).owner rescue
instance_method(:_d).owner;eval "undef _d";y'

class Foo
puts eval DEFINEE #=> Foo
end

Really ugly. Really works.

Changes self? Changes deﬁnee?

class C C C

C.class_eval C C

C.instance_eval C C.singleton_class

obj.instance_eval obj obj.singleton_class

(in C) def foo obj obj.singleton_class

obj.send :eval obj NO CHANGE

class << obj obj.singleton_class obj.singleton_class

Ruby Internals

More Related Content

Ruby Internals

Editor's Notes