Instance variable implementation 1.8 vs. 1.9

I've been reading the code for both 1.8 and 1.9, and I wanted to make
sure that I understand instance variable access and how it has
changed.  Here's my understanding.

1.8

Each non-immediate object or at least each object instance mapped by
RObject has a pointer iv_tbl to a hash table mapping it's instance
variable names in symbol form to the value of that particular
instance's variable for that particular instance.  The hash table will
only have entries for variables which have been either set or accessed
during execution of a method on that instance.

1.9

ROBJECT no longer has an iv_tbl, instead it has been moved to the
object's class, and instead of mapping the instance variable name to a
value, it maps it to an index, this table is shared by all direct
instances of the class, but it is NOT inherited.
      if obj->klass->iv_tbl doesn't exist when an instance variable is
being set a new empty table is created without looking up the
inheritance chain.
      If the instance variable name is not found in obj->klass->iv_tbl
it is not looked for up the chain, and the instance variable will just
be nil on a get, undefined on a defined? or for a set a new index will
be allocated and used for the instance variable.

The actual instance variable VALUEs are stored directly in  the object
if there are no instance variables in the INSTANCE with an index less
than ROBJECT_EMBED_LEN_MAX  (currently 3), or if there are more than
three, the object contains a  len field with the maximum index and a
pointer to a separate special object containing the array of values.
In either case the VALUE for an instance variable will contain the
special value q_undef which is distinct from nil.

As far as I've been able to see so far, the actual semantics are
unchanged, instances either have or don't have a given instance
variable independent of their class. The new implementation amortizes
the space of the hash table over a number of instances.  It's also the
case, I think that in a case like this:

class A
     attr_accessor :a
end

class B
    attr_accessor :b
end

a = A.new
b = B.new
b2 = B.new

a.a = 1
b.b = 2
b.a = 3
b2.a = 4

That the objects would be laid out like this:

		a --> klass -----> A.iv_tbl => {:a => 0}
slot0	1

        b --> klass -----> B.iv_tbl => {:b => 0, :a => 1}
slot0   2                  |
slot1   3                  |
                           |
        b2 -> klass -------+
slot0   qUndef
slot1   4

Do I have this basically right?

-- 
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denhaven2.com/