• d coder (15/15) Mar 15 2011 Greetings
• Nick Treleaven (13/24) Mar 16 2011 I'm certainly no expert, but it seems the cast is the problem - this
• Nick Treleaven (3/13) Mar 17 2011 This seems like a compiler bug, so filed:
• SHOO (19/35) Mar 16 2011 This is the very interesting agenda.

d coder <dlang.coder gmail.com> writes:

Greetings

I am trying to create a multithreaded application. Right now I am finding it
difficult to work with "shared" qualifier. One of the reasons is that Phobos
library does not seem compatible with "shared" data-structures. For example:

import std.bitmanip;
shared BitArray foo;
void main() {
  foo ~= true; // this does not work
  (cast(BitArray)foo) ~= true; // Even casting does not help
}


I know that "shared" is a relatively new qualifier in D2. Are there plans to
make Phobos "shared" compatible?
Are there any workarounds that I am missing.

Regards
- Puneet

Nick Treleaven <nospam example.net> writes:

On Tue, 15 Mar 2011 19:52:14 +0530, d coder wrote:

 import std.bitmanip;
 shared BitArray foo;
 void main() {
   foo ~= true; // this does not work
   (cast(BitArray)foo) ~= true; // Even casting does not help
 }
 
 
 I know that "shared" is a relatively new qualifier in D2. Are there
 plans to make Phobos "shared" compatible?

I'm certainly no expert, but it seems the cast is the problem - this 
causes an error:

auto f = cast(BitArray)foo;

shared.d(21): Error: function std.bitmanip.BitArray.opCast () is not 
callable using argument types ()
shared.d(21): Error: cannot implicitly convert expression (foo.opCast()) 
of type void[] to BitArray

Without shared, the cast is fine. It seems the problem is casting a 
shared struct instance that defines opCast (at least like 
BitArray.opCast, returning void[]).

 Are there any workarounds that I am missing.

If you're desperate, you can use __gshared instead of shared but this is 
then completely up to you to ensure no data races for foo.

Nick Treleaven <nospam example.net> writes:

On Wed, 16 Mar 2011 17:42:09 +0000, Nick Treleaven wrote:

 auto f = cast(BitArray)foo;
 
 shared.d(21): Error: function std.bitmanip.BitArray.opCast () is not
 callable using argument types ()
 shared.d(21): Error: cannot implicitly convert expression (foo.opCast())
 of type void[] to BitArray
 
 Without shared, the cast is fine. It seems the problem is casting a
 shared struct instance that defines opCast (at least like
 BitArray.opCast, returning void[]).

This seems like a compiler bug, so filed:
http://d.puremagic.com/issues/show_bug.cgi?id=5747

SHOO <zan77137 nifty.com> writes:

This is the very interesting agenda.

I know a method, but don't know that the method is recommended:

import std.bitmanip;
shared BitArray foo;
void main(){
	(*cast(BitArray*)&foo) ~= true;
}

In addition, your code is filled up many 'cast' if you try to solve it 
by this method.
This is clearly unfavorable.


See also: http://www.informit.com/articles/article.aspx?p=1609144

This article says that the basic policy about the multi-thread uses 
message passing. When you use message passing, these problems rarely occur.
However, it is important that it is easily feasible even if it is other 
methods.

I want to know a policy about this agenda.

--
SHOO


(2011/03/15 23:22), d coder wrote:
 Greetings

 I am trying to create a multithreaded application. Right now I am
 finding it difficult to work with "shared" qualifier. One of the reasons
 is that Phobos library does not seem compatible with "shared"
 data-structures. For example:

 import std.bitmanip;
 shared BitArray foo;
 void main() {
    foo ~= true;// this does not work
    (cast(BitArray)foo) ~= true;// Even casting does not help
 }


 I know that "shared" is a relatively new qualifier in D2. Are there
 plans to make Phobos "shared" compatible?
 Are there any workarounds that I am missing.

 Regards
 - Puneet