emplace, scope, enforce [Was: Re: Manual...]

[Dmitry Olshansky]

On 21.07.2010 14:20, bearophile wrote:
> Dmitry Olshansky:
>    
>> Well, I'm using this for structs, very straightforward:
>>
>> T* create(T, Args...)(Args args)
>> if ( !is(T == class) ){
>>       return emplace!T(malloc(T.sizeof)[0..T.sizeof], args);
>> }
>>      
> That's not good enough, you are allocating on the (C) heap. If you use that in the D benchmark I have shown you probably can get bad timing results.
>
>    
Uh, yes I guess I should have read your post to the end :). Stack 
allocation is risky business to say least. Some kind of memory pool 
should be handy.
>> This is dtor not get called, and it's because emplace is a library
>> replacement for placement new( no pun).
>> Sure enough with manual memory management you need to call clear(t) at exit.
>>      
> If the class is allocated on the stack it's much better if the destructor is called when the class gets out of scope. Otherwise it's like C programming.
> (I suggest to edit your post, to remove useless parts of the original post.)
>
>    
To that end one should prefer vanilla structs with destructor, not final 
classes and scope. That's, of course, losing the inheritance and such.
The problem is designing such classes and then documenting: "you should 
always use it as 'scope' ", is awkward.
Moreover, the function which you pass the stack allocated class instance 
are unaware of that clever trick.

Slight modification of your benchmark:

import std.conv: emplace;
import std.contracts;

import std.stdio;
final class Test { // 32 bytes each instance
     int i1, i2, i3, i4, i5, i6;
     this(int ii1, int ii2, int ii3, int ii4, int ii5, int ii6) {
         this.i1 = ii1;
         this.i2 = ii2;
         this.i3 = ii3;
         this.i4 = ii4;
         this.i5 = ii5;
         this.i6 = ii6;
     }
     void doSomething(int ii1, int ii2, int ii3, int ii4, int ii5, int 
ii6) {
     }
}

Test hidden;

void fun(Test t){
     hidden = t;
}

void bench(){
     enum int N = 10_000_000;
     int i;

     while (i < N) {
         scope Test testObject = new Test(i, i, i, i, i, i);
         fun(testObject);
         testObject.doSomething(i, i, i, i, i, i);
         testObject.doSomething(i, i, i, i, i, i);
         testObject.doSomething(i, i, i, i, i, i);
         testObject.doSomething(i, i, i, i, i, i);
         i++;
     }

}

void main() {
     int a,b,c;//
     bench();
//what's the hidden now?
     writefln("%d %d", hidden.i1,hidden.i2);
     writefln("%d %d", hidden.i1,hidden.i2);
}

The second writefln prints garbage. I guess it's because of pointer to 
the long gone stackframe, which is ovewritten by the first writeln.

-- 
Dmitry Olshansky