www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Static constructors in structs.

reply TheFlyingFiddle <borin.lukas gmail.com> writes:
Is this intended to work?

struct A
{
    __gshared static this()
    {
       //Add some reflection info to some global stuff.
       addReflectionInfo!(typeof(this));
    }
}

I just noticed this works in 2.069, is this intended? I mean I 
love it! It makes it possible to do lot's of useful mixins for 
runtime reflection for example. Just wondering if I can start 
writing code this way or if it's a regression and is going away. 
I think this did not work a year ago when I tried doing something 
like this.
Oct 30 2015
next sibling parent reply anonymous <anonymous example.com> writes:
On 30.10.2015 21:23, TheFlyingFiddle wrote:

 Is this intended to work?

 struct A
 {
     __gshared static this()
     {
        //Add some reflection info to some global stuff.
        addReflectionInfo!(typeof(this));
     }
 }

 I just noticed this works in 2.069, is this intended?


static constructors are supposed to work, yes.

The description is on the class page: 
http://dlang.org/class.html#static-constructor

__gshared doesn't do anything there, though. Use `shared static this` 
instead, if you want the constructor to run only once per process, and 
not once per thread.
Oct 30 2015
next sibling parent TheFlyingFiddle <borin.lukas gmail.com> writes:
On Friday, 30 October 2015 at 20:58:37 UTC, anonymous wrote:

 On 30.10.2015 21:23, TheFlyingFiddle wrote:

 Is this intended to work?

 struct A
 {
     __gshared static this()
     {
        //Add some reflection info to some global stuff.
        addReflectionInfo!(typeof(this));
     }
 }

 I just noticed this works in 2.069, is this intended?


 static constructors are supposed to work, yes.

 The description is on the class page: 
 http://dlang.org/class.html#static-constructor

 __gshared doesn't do anything there, though. Use `shared static 
 this` instead, if you want the constructor to run only once per 
 process, and not once per thread.


Was under the impression that __gshared did the same thing for 
static constructors. Thanks.
Oct 30 2015
prev sibling parent reply BBasile <bb.temp gmx.com> writes:
On Friday, 30 October 2015 at 20:58:37 UTC, anonymous wrote:

 On 30.10.2015 21:23, TheFlyingFiddle wrote:

 Is this intended to work?

 struct A
 {
     __gshared static this()
     {
        //Add some reflection info to some global stuff.
        addReflectionInfo!(typeof(this));
     }
 }

 I just noticed this works in 2.069, is this intended?


 static constructors are supposed to work, yes.

 The description is on the class page: 
 http://dlang.org/class.html#static-constructor

 __gshared doesn't do anything there, though. Use `shared static 
 this` instead, if you want the constructor to run only once per 
 process, and not once per thread.


__gshared is mostly usefull on fields (eg public uint a) because 
it prevents a data to be put on the TLS, which in certain case 
reduces the perfs up to 30%. The byte code using a global 
variable that's not __gshared can be incredibly slower !
Oct 30 2015
next sibling parent BBasile <bb.temp gmx.com> writes:
On Friday, 30 October 2015 at 21:29:22 UTC, BBasile wrote:

 On Friday, 30 October 2015 at 20:58:37 UTC, anonymous wrote:

 On 30.10.2015 21:23, TheFlyingFiddle wrote:

 Is this intended to work?

 struct A
 {
     __gshared static this()
     {
        //Add some reflection info to some global stuff.
        addReflectionInfo!(typeof(this));
     }
 }

 I just noticed this works in 2.069, is this intended?


 static constructors are supposed to work, yes.

 The description is on the class page: 
 http://dlang.org/class.html#static-constructor

 __gshared doesn't do anything there, though. Use `shared 
 static this` instead, if you want the constructor to run only 
 once per process, and not once per thread.


 __gshared is mostly usefull on fields (eg public uint a) 
 because it prevents a data to be put on the TLS, which in 
 certain case reduces the perfs up to 30%. The byte code using a 
 global variable that's not __gshared can be incredibly slower !


Im' talking about DMD win32 BTW. Even if now I've switched to 
full time linux, I have a test on the hold HDD that demonstrates 
this :). That's really uncredible. Avoid TLS as possible on DMD 
with the switch "-vtls".
Oct 30 2015
prev sibling next sibling parent TheFlyingFiddle <borin.lukas gmail.com> writes:
On Friday, 30 October 2015 at 21:29:22 UTC, BBasile wrote:

 __gshared is mostly usefull on fields (eg public uint a) 
 because it prevents a data to be put on the TLS, which in 
 certain case reduces the perfs up to 30%. The byte code using a 
 global variable that's not __gshared can be incredibly slower !


I have gotten used to using __gshared on fields so much that I 
just naturally assumed that shared static this() { } would be 
equivalent to __gshared static this() { } :P. I find they can be 
very useful for data that initialized in static constructors and 
then never change again (I will have to fix my shared 
constructors now :S guess i have been lucky not running into race 
problems before).
Oct 30 2015
prev sibling parent Adam D. Ruppe <destructionator gmail.com> writes:
On Friday, 30 October 2015 at 21:29:22 UTC, BBasile wrote:

 __gshared is mostly usefull on fields (eg public uint a)


That's only true if it is at the module level or static. Ordinary 
struct members are whatever the container is and class members 
are on the heap unless you do something fancy.

module test;

int tls; // this is in tls
shared(int) s; // this is not TLS
__gshared int s; // also not TLS, same as shared(), but doesn't 
change the type

struct Foo {
    int var; // will be TLS only is the instance is TLS
    static int tls; // put in TLS
    shared(int) s; // not TLS
    __gshared int s; // also not TLS
}

class Foo {
    int var; // not TLS unless you do some weird allocation scheme
    static int tls; // TLS
    // you get the idea now
}


 because it prevents a data to be put on the TLS, which in 
 certain case reduces the perfs up to 30%. The byte code using a 
 global variable that's not __gshared can be incredibly slower !


right, TLS has some cost but it has benefits too. Best 
performance is often gotten by not using globals much at all - 
try to get a local copy on the stack to work with. Then you will 
more likely be in the CPU cache and can see enormous speedups.
Oct 30 2015
prev sibling parent reply Adam D. Ruppe <destructionator gmail.com> writes:
On Friday, 30 October 2015 at 20:23:45 UTC, TheFlyingFiddle wrote:

 I just noticed this works in 2.069, is this intended?


I thought it always worked. The __gshared there I'm pretty sure 
doesn't do anything and should prolly be removed.

The two forms are `static this` which is called for each thread 
and `shared static this` which is only called once per process. 
The compiler literally looks for the sequence of keywords there, 
so they need to be exactly in that order.

But yeah, the struct feature table http://dlang.org/struct.html 
shows them as checked.
Oct 30 2015
parent TheFlyingFiddle <borin.lukas gmail.com> writes:
On Friday, 30 October 2015 at 20:59:46 UTC, Adam D. Ruppe wrote:

 On Friday, 30 October 2015 at 20:23:45 UTC, TheFlyingFiddle 
 wrote:
 But yeah, the struct feature table http://dlang.org/struct.html 
 shows them as checked.


I gotta say the language documentation is shaping up nicely.
Oct 30 2015