Shared Hell
Denis Koroskin
2korden at gmail.com
Tue Oct 27 22:05:46 PDT 2009
I've recently updated to DMD2.035 (from DMD2.031 because all the later
versions had issues with imports) and for the first time faced problems
with shared modifier.
I don't need shared and all my globals are __gshared (they are globally
unique instances that don't need per-thread copies).
Yet some of methods of the class hierarchy (a root singleton class and
everything which is accessible through it) are synchronized (well, you
know why). That's where the problems begin.
Marking a method as synchronized automatically makes it shared (more or
less obvious). And marking the method shared makes it unable to invoke
with non-shared instance (and __gshared != shared), meaning that I'm
unable to use my __gshared variables anymore, making this attribute
useless for any serious safe programming.
So I started with replacing __gshared with shared and quickly understood
how viral it is. Not only you mast mark all the members shared (methods
and field), instantiate classes with shared attribute, you also have to
create a duplicate all the methods to make them accessible with both
shared and non-shared (thread-local) instances:
class Array(T)
{
const(T) opIndex(uint index) const
{
return data[index];
}
T opIndex(uint index)
{
return data[index];
}
const(T) opIndex(uint index) shared const
{
return data[index];
}
shared(T) opIndex(uint index) shared
{
return data[index];
}
private T[] data;
}
And that's just opIndex. Ooops...
But not only that, every interface now have to specify the same method
twice, too:
interface Target
{
bool build();
bool build() shared;
void clean();
void clean() shared;
bool ready();
bool ready() shared;
void setBuildListener(BuildListener buildListener);
void setBuildListener(shared BuildListener buildListener) shared;
}
That's a bit frustrating. Most importantly, I don't even need shared
(__gshared was more than enough for me), yet I'm imposed on using it.
Oh, I can't use any of the druntime/Phobos classes (e.g. create an
instance of shared(Thread)), because none of them are shared-aware.
I think the design needs to be given a second thought before the plane
takes off because I'm afraid it may painfully crash.
More information about the Digitalmars-d
mailing list