www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - __gshared implicitly convertible to shared?

reply Jonathan M Davis <jmdavisProg gmx.com> writes:
Would it make sense to make it so that __gshared implicitly converted to 
shared? It's my understanding that the main purpose of __gshared is to be able 
to better interact with C code, but given the issues with shared, lots of 
people have just used __gshared instead of shared. This causes a problem in 
some cases. For instance, none of Mutex's functions are currently shared in 
spite of the fact that it really doesn't make sense to have a Mutex which is 
thread-local, but it can't have all of its functions be only shared, because 
then it wouldn't work with __gshared. That means that in order to work with 
both __gshared and shared, all of its functions must be duplicated, which is 
obviously less than ideal.

So, given that __gshared is shared across threads like shared is (just with 
fewer protections), would it make sense to make it so that __gshared 
implicitly converts to shared? Then a type like Mutex which is intended to be 
shared, can just make all of its member functions shared, and it'll work with 
both __gshared and shared.

It may also be necessary to make shared implicitly convert to __gshared for 
that to work cleanly (particularly when you get stuff like a member function 
returning a reference variable which then must be shared, even if the original 
variable were __gshared - because the function itself is shared), and I don't 
know how big a problem that would be. But I think that the basic idea of 
allowing implicit conversions at least from __gshared to shared (if not shared 
to __gshared) is worth exploring. Is there a major reason why it would be a 
bad idea? My experience with both is limited, and I may just be completely 
missing something here.

- Jonathan M Davis
Nov 20 2012
next sibling parent "Chris Nicholson-Sauls" <ibisbasenji gmail.com> writes:
On Tuesday, 20 November 2012 at 19:15:01 UTC, Jonathan M Davis 
wrote:
 Would it make sense to make it so that __gshared implicitly 
 converted to
 shared? It's my understanding that the main purpose of 
 __gshared is to be able
 to better interact with C code, but given the issues with 
 shared, lots of
 people have just used __gshared instead of shared. This causes 
 a problem in
 some cases. For instance, none of Mutex's functions are 
 currently shared in
 spite of the fact that it really doesn't make sense to have a 
 Mutex which is
 thread-local, but it can't have all of its functions be only 
 shared, because
 then it wouldn't work with __gshared. That means that in order 
 to work with
 both __gshared and shared, all of its functions must be 
 duplicated, which is
 obviously less than ideal.

 So, given that __gshared is shared across threads like shared 
 is (just with
 fewer protections), would it make sense to make it so that 
 __gshared
 implicitly converts to shared? Then a type like Mutex which is 
 intended to be
 shared, can just make all of its member functions shared, and 
 it'll work with
 both __gshared and shared.

 It may also be necessary to make shared implicitly convert to 
 __gshared for
 that to work cleanly (particularly when you get stuff like a 
 member function
 returning a reference variable which then must be shared, even 
 if the original
 variable were __gshared - because the function itself is 
 shared), and I don't
 know how big a problem that would be. But I think that the 
 basic idea of
 allowing implicit conversions at least from __gshared to shared 
 (if not shared
 to __gshared) is worth exploring. Is there a major reason why 
 it would be a
 bad idea? My experience with both is limited, and I may just be 
 completely
 missing something here.

 - Jonathan M Davis

I'm short on time, and so can't double-check the online docs or the book, but as I recall (having never actually used __gshared... yet) they differ in that shared is a type constructor and __gshared is a declaration attribute. So I'm just not sure. On the one hand, the compiler would always be able to see that either the left or right side of an assignment (or the inside of an argument list) includes a __gshared variable, and could do the "right" thing... But on the other hand it would be an odd special case of a type qualifier being cast away because of a variable's attribute. Is this something we want? Or is it intended as a short-term workaround until shared is more fully/correctly defined semantically?
Nov 20 2012
prev sibling parent Jacob Carlborg <doob me.com> writes:
On 2012-11-20 20:14, Jonathan M Davis wrote:
 Would it make sense to make it so that __gshared implicitly converted to
 shared? It's my understanding that the main purpose of __gshared is to be able
 to better interact with C code, but given the issues with shared, lots of
 people have just used __gshared instead of shared.

I don't think it's just because there are issues with "shared". If "shared" means other semantics than just a global variable the D code will have different semantics when accessing the variable compared to the C code. I don't think that's a good idea. If it's not safe to just access the variable as is, I think it's better to add a safe wrapper then changing the semantics of the bindings. -- /Jacob Carlborg
Nov 20 2012