On 08/08/2013 01:08 PM, JR wrote:
> The first concurrency message passed is a string, which works as
> expected. The second message is the translated struct of over 32 bytes
> in size (96 to be exact), and that's where things start breaking.
I came across the following bug just the other day. It may be related:
"std.concurrency send() fails with structs over 32 bytes"
http://d.puremagic.com/issues/show_bug.cgi?id=10740
> Passing an immutable pointer *initially* works, but then you get a race
> to finish using the struct before the scope it was declared in ends.
An immutable on the receiving side is a request to the caller that the
data must be immutable. If you are casting data with mutable indirection
to immutable, anything can happen.
immutable data is by nature not synchronized because it is read-only.
(Of course you can synchronize if you know that it is casted data to
begin with.)
Have you considered the 'shared' attribute? You are still responsible
for dealing with race conditions.
> Are there any easy workarounds?
Messages are supposed to solve race conditions. Once a message gets some
data nobody else should write to that data.
> Do people use std.concurrency, or is it largely avoided?
I have used it only in test code. I am not aware of major problems other
than some Variant-related issues that you also mention.
Ali
