Hi Ian,

    You are marvelous, now I can start to learn the real live object. :-)

    Cheers,

    PhiHo.

----- Original Message -----
From: "Ian Piumarta" <ian.piumarta at inria.fr>
To: <squeak-dev at lists.squeakfoundation.org>
Sent: Tuesday, October 29, 2002 1:35 PM
Subject: Re: Object Format


> Hi PhiHo,
>
> On Tue, 29 Oct 2002, PhiHo Hoang wrote:
> >
> > > 8-11   10xx indexable byte fields only (no pointers)
> > > 12-15 11xx compiled methods: # of literal oops specified in method
header
> >
> >     What are these 2 bits 'xx' ? In your slides, you said they are 'low
2
> > "excess" size bits'.
>
> It's for byte objects only and is needed because every object's size
> is rounded up to an integral number of words (multiple of 4 bytes).
>
> Say you have a byte object containing 6 bytes, it looks like this:
>
> +-------------------------------+
> |     base header (4 bytes)     |
> +-------+-------+-------+-------+
> | byte1 | byte2 | byte2 | byte4 |
> +-------+-------+-------+-------+
> | byte5 | byte6 |  xxx     xxx  | xxx = unused byte
> +-------+-------+---------------+
> |      ... next object ...      |
>
> The size stored in the base header (or in an extra size word before
> the base header) gives the object's size as a number of _words_.
> Because the object occupies three words in memory this size will be
> three words, which implies a length of 12 bytes.  However, your byte
> object is really two bytes short of the size implied by the value in
> the header: it's only 10 bytes long, not 12.  This missing information
> (by how many bytes the object is short of the size implied by its word
> size) is stored in the `xx' bits of the format field.
>
> For example, given a byte object with format F >= 8 of word size W,
> the actual indexable size (number of bytes you're allowed to access
> from within Smalltalk) is
>
> (W * 4) - 4 - (F & 3)
>
> i.e., convert words to bytes, then subtract the size of the base
> header, then subtract the low two bits of the format (which are the
> `excess size').
>
> >     Where are the compact class located in the Object Memory ?
>
> They're in an Array, which is itself stored in the specialObjectsArray
> (from where the VM can get to it).  Look at:
>
> Smalltalk compactClassesArray
>
> which answers the array itself, and in the methods:
>
> SystemDictionary>>compactClassesArray
> SystemDictionary>>recreateSpecialObjectsArray
>
> which deal with its presence in the special objects array, and in
> methods like:
>
> Behavior>>becomeCompact
> Behavior>>becomeUncompact
>
> which show how it is manipulated within the image.
>
> >     Having a 5-bit compact class index, how do you get at that class ?
>
> In Smalltalk you use:
>
> Smalltalk compactClassesArray at: index.
>
> (index 0 means non-compact, so it is always at least 1).  In the VM
> (i.e., methods in class Interpreter) you would use something like:
>
> self fetchPointer: index - 1
>      ofObject: (self splObj: CompactClasses)
>
> where CompactClasses is 28 (i.e., the 29th element of the special
> objects array).
>
> >     Thanks,
>
> You're welcome.
>
> Ian
>
>