How does one determine the sizeof (in bytes) of an instance of a class in D?

.sizeof works as advertised for structs, but for reference types,
.sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
and not the size of the underlying instance.

I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.

btw. I was poking under the hood of std.xml and though, wow, instances of Element class look humongous, and so I'm interested to how exactly how humongous.

Thanks for all help.
Justin

Justin Johansson wrote:
> How does one determine the sizeof (in bytes) of an instance of a class in D?
> 
> .sizeof works as advertised for structs, but for reference types,
> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
> and not the size of the underlying instance.
> 
> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
> 
> btw. I was poking under the hood of std.xml and though, wow, instances of Element
> class look humongous, and so I'm interested to how exactly how humongous.
> 
> Thanks for all help.
> Justin
> 

The only way I know of is to access the init array of the classinfo at runtime and get its length property.

On Sat, Oct 3, 2009 at 5:50 PM, Justin Johansson <no@spam.com> wrote:
> How does one determine the sizeof (in bytes) of an instance of a class in D?
>
> .sizeof works as advertised for structs, but for reference types,
> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
> and not the size of the underlying instance.
>
> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
>
> btw. I was poking under the hood of std.xml and though, wow, instances of Element class look humongous, and so I'm interested to how exactly how humongous.
>
> Thanks for all help.
> Justin

There's no way to get it at compile-time in D1. The best you can do is Class.classinfo.init.length.

In D2, you can use __traits(classInstanceSize, Class).

Jarrett Billingsley Wrote:

> On Sat, Oct 3, 2009 at 5:50 PM, Justin Johansson <no@spam.com> wrote:
> > How does one determine the sizeof (in bytes) of an instance of a class in D?
> >
> > .sizeof works as advertised for structs, but for reference types,
> > .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
> > and not the size of the underlying instance.
> >
> > I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
> >
> > btw. I was poking under the hood of std.xml and though, wow, instances of Element class look humongous, and so I'm interested to how exactly how humongous.

> There's no way to get it at compile-time in D1. The best you can do is Class.classinfo.init.length.
> 
> In D2, you can use __traits(classInstanceSize, Class).


Thanks Jeremie and Jarrett for answers.

For investigative purposes (rather than adding up class member sizes in my head),
would I get a fair answer if I copied the class data members into a struct, did a struct
sizeof and added 4 bytes to allow for a virtual function table pointer (in the class and
assuming the class has a VFT)?

Justin Johansson wrote:
> Jarrett Billingsley Wrote:
> 
>> On Sat, Oct 3, 2009 at 5:50 PM, Justin Johansson <no@spam.com> wrote:
>>> How does one determine the sizeof (in bytes) of an instance of a class in D?
>>>
>>> .sizeof works as advertised for structs, but for reference types,
>>> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
>>> and not the size of the underlying instance.
>>>
>>> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
>>>
>>> btw. I was poking under the hood of std.xml and though, wow, instances of Element
>>> class look humongous, and so I'm interested to how exactly how humongous.
> 
>> There's no way to get it at compile-time in D1. The best you can do is
>> Class.classinfo.init.length.
>>
>> In D2, you can use __traits(classInstanceSize, Class).
> 
> 
> Thanks Jeremie and Jarrett for answers.
> 
> For investigative purposes (rather than adding up class member sizes in my head),
> would I get a fair answer if I copied the class data members into a struct, did a struct
> sizeof and added 4 bytes to allow for a virtual function table pointer (in the class and
> assuming the class has a VFT)?

You forgot the monitor pointer of the class, so thats (size_t.sizeof * 2) to add to the size of the struct.

I wasn't aware of the traits method either, I just made this helper template to simplify its syntax:

template SizeOf(alias C) if(is(C == class)) {
	enum ClassSizeof = __traits(classInstanceSize, C);
}

Jeremie Pelletier Wrote:

> Justin Johansson wrote:
> > Jarrett Billingsley Wrote:
> > 
> >> On Sat, Oct 3, 2009 at 5:50 PM, Justin Johansson <no@spam.com> wrote:
> >>> How does one determine the sizeof (in bytes) of an instance of a class in D?
> >>>
> >>> .sizeof works as advertised for structs, but for reference types,
> >>> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
> >>> and not the size of the underlying instance.
> >>>
> >>> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
> >>>
> >>> btw. I was poking under the hood of std.xml and though, wow, instances of Element class look humongous, and so I'm interested to how exactly how humongous.
> > 
> >> There's no way to get it at compile-time in D1. The best you can do is Class.classinfo.init.length.
> >>
> >> In D2, you can use __traits(classInstanceSize, Class).
> > 
> > 
> > Thanks Jeremie and Jarrett for answers.
> > 
> > For investigative purposes (rather than adding up class member sizes in my head),
> > would I get a fair answer if I copied the class data members into a struct, did a struct
> > sizeof and added 4 bytes to allow for a virtual function table pointer (in the class and
> > assuming the class has a VFT)?
> 
> You forgot the monitor pointer of the class, so thats (size_t.sizeof * 2) to add to the size of the struct.
> 
> I wasn't aware of the traits method either, I just made this helper template to simplify its syntax:
> 
> template SizeOf(alias C) if(is(C == class)) {
> 	enum ClassSizeof = __traits(classInstanceSize, C);
> }


Sorry I misread the earlier answer.  This works for my investigative purposes as explained:

   writefln( "Element instance size = %d", Element.classinfo.init.length);

Still glad I asked this last question though because I hadn't thought of monitor.  Also I imagine that if a class has interfaces, this can impact upon the size as well.

My early years with microprocessors (8085, 8086, 6809 etc) and assembly language has always made me curious about how compilers realize their magic at the bit and byte level.

Jarrett Billingsley wrote:
> On Sat, Oct 3, 2009 at 5:50 PM, Justin Johansson <no@spam.com> wrote:
>> How does one determine the sizeof (in bytes) of an instance of a class in D?
>>
>> .sizeof works as advertised for structs, but for reference types,
>> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
>> and not the size of the underlying instance.
>>
>> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
>>
>> btw. I was poking under the hood of std.xml and though, wow, instances of Element class look humongous, and so I'm interested to how exactly how humongous.
>>
>> Thanks for all help.
>> Justin
> 
> There's no way to get it at compile-time in D1. The best you can do is Class.classinfo.init.length.

What nonsense, of course there is!

http://gist.github.com/140531

Note: this is VERY old code, but I have no reason to think it won't still work.  I may need a little dusting off...

Daniel Keep wrote:
> ...
> Note: this is VERY old code, but I have no reason to think it won't
> still work.  I may need a little dusting off...

*It* may need a little dusting off.  Argh.

Jeremie Pelletier Wrote:

> Justin Johansson wrote:
> > Jarrett Billingsley Wrote:
> > 
> >> On Sat, Oct 3, 2009 at 5:50 PM, Justin Johansson <no@spam.com> wrote:
> >>> How does one determine the sizeof (in bytes) of an instance of a class in D?
> >>>
> >>> .sizeof works as advertised for structs, but for reference types,
> >>> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
> >>> and not the size of the underlying instance.
> >>>
> >>> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.
> >>>
> >>> btw. I was poking under the hood of std.xml and though, wow, instances of Element class look humongous, and so I'm interested to how exactly how humongous.
> > 
> >> There's no way to get it at compile-time in D1. The best you can do is Class.classinfo.init.length.
> >>
> >> In D2, you can use __traits(classInstanceSize, Class).
> > 
> > 
> > Thanks Jeremie and Jarrett for answers.
> > 
> > For investigative purposes (rather than adding up class member sizes in my head),
> > would I get a fair answer if I copied the class data members into a struct, did a struct
> > sizeof and added 4 bytes to allow for a virtual function table pointer (in the class and
> > assuming the class has a VFT)?
> 
> You forgot the monitor pointer of the class, so thats (size_t.sizeof * 2) to add to the size of the struct.
> 
> I wasn't aware of the traits method either, I just made this helper template to simplify its syntax:
> 
> template SizeOf(alias C) if(is(C == class)) {
> 	enum ClassSizeof = __traits(classInstanceSize, C);
> }

Okay so PODO alone is 8 bytes.

   writefln( "Object:      %d", Object.classinfo.init.length);

Object:      8

And we're talking 9 bytes for a simple boxed bool and 12 bytes for a simple boxed 32-bit integer by the looks of things.

class Foo {
   bool value;
}

class Bar {
   int value;
}

   writefln( "Foo:         %d", Foo.classinfo.init.length);
   writefln( "Bar:         %d", Bar.classinfo.init.length);

Foo:         9
Bar:         12

On top of that there is possibly alignment in the heap so my 9 byte Foo would occupy 12 or 16 bytes of address space.  Would that be correct?

Thanks for answers.  Justin.

Justin Johansson wrote:
> How does one determine the sizeof (in bytes) of an instance of a class in D?
> 
> .sizeof works as advertised for structs, but for reference types,
> .sizeof yields the sizeof the referencing variable (effectively same as size of a pointer)
> and not the size of the underlying instance.

As Jarrett said, x.classinfo.init.length is the simplest way in D1.

> I did try scanning the NG and read spec_D1.00.pdf.  Perhaps I missed it in the latter.

I guess that PDF is horribly outdated, although it may work for some purposes.

> btw. I was poking under the hood of std.xml and though, wow, instances of Element
> class look humongous, and so I'm interested to how exactly how humongous.

Wasn't std.xml for D2? Anyway, last what I remember is that std.xml is unmaintained, slow, buggy, and shouldn't be seriously used.

> Thanks for all help.
> Justin
>