www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - std.concurrency bug?

reply Charles Hixson via Digitalmars-d-learn writes:
Is it a bug that an immutable struct cannot be sent to a thread?  (It compiles 
without problem if I make all elements mutable.)
May 20 2014
parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 05/20/2014 11:38 AM, Charles Hixson via Digitalmars-d-learn wrote:
 Is it a bug that an immutable struct cannot be sent to a thread?  (It compiles
 without problem if I make all elements mutable.)
Does the struct have any mutable indirection? Then it is illegal. Otherwise, can you demonstrate with minimal code please? Ali
May 20 2014
next sibling parent Charles Hixson via Digitalmars-d-learn writes:
On Tuesday, May 20, 2014 11:42:48 AM Ali Çehreli via Digitalmars-d-learn 
wrote:
 On 05/20/2014 11:38 AM, Charles Hixson via Digitalmars-d-learn wrote:
 Is it a bug that an immutable struct cannot be sent to a thread?  (It
 compiles without problem if I make all elements mutable.)
Does the struct have any mutable indirection? Then it is illegal. Otherwise, can you demonstrate with minimal code please? Ali
Nope. Here it is (with the immutable tags removed): /** This is the only message that one cell sends to another. */ struct Msg { /** The cell id# of the sender of the message. */ uint64_t from; /** The cell id# of the recipient of the message. */ uint64_t to; /** The kind of action the message is impelling. */ Act act; /** The tick on which the message was accepted for transmission. * This is set by std.datetime.Clock.currStdTime() */ long tick; /** Distance between cells. Not currently well defined except in * the case of two words, in which case it is the number of words of * separation, where adjacent is 1. */ float dist; /** Not currently well defined. */ int value; this (uint64_t from, uint64_t to, Act act, float dist, int value) { this.from = from; this.to = to; this.act = act; this.tick = Clock.currStdTime; this.dist = dist; this.value = value; } }
May 20 2014
prev sibling parent reply Charles Hixson via Digitalmars-d-learn writes:
On Tuesday, May 20, 2014 11:42:48 AM Ali Çehreli via Digitalmars-d-learn 
wrote:
 On 05/20/2014 11:38 AM, Charles Hixson via Digitalmars-d-learn wrote:
 Is it a bug that an immutable struct cannot be sent to a thread?  (It
 compiles without problem if I make all elements mutable.)
Does the struct have any mutable indirection? Then it is illegal. Otherwise, can you demonstrate with minimal code please? Ali
Nearly a minimal example. If "void sendMsg (Msg m){...}" is removed there's not compilation error. import std.array; import std.concurrency; import std.datetime; import std.format; import std.stdio; import std.stdint; import std.string; import std.variant; enum numCThreads = 4; class UnexpectedMessage : Exception { this (string s) { super (s); } } enum Act {create, activate, deactivate, wait, read, reset, save, done} string toString(E)(E value) if (is(E == enum)) { foreach (s; __traits(allMembers, E)) { if (value == mixin("E." ~ s) ) return s; } return null; } // string toString (... for enum /** This is the only message that one cell sends to another. */ struct Msg { /** The cell id# of the sender of the message. */ immutable uint64_t from; /** The cell id# of the recipient of the message. */ immutable uint64_t to; /** The kind of action the message is impelling. */ immutable Act act; /** The tick on which the message was accepted for transmission. * This is set by std.datetime.Clock.currStdTime() */ immutable long tick; /** Distance between cells. Not currently well defined except in * the case of two words, in which case it is the number of words of * separation, where adjacent is 1. */ immutable float dist; /** Not currently well defined. */ immutable int value; this (uint64_t from, uint64_t to, Act act, float dist, int value) { this.from = from; this.to = to; this.act = act; this.tick = Clock.currStdTime; this.dist = dist; this.value = value; } } void cellThread(size_t ndx, shared(Tid)[] cThreads) { /** Unprocessed message queue, indexed by cell id#. */ Msg msgs[uint64_t][]; bool done = false; //TODO load the cells into the thread /** Receive all messages in the mailbox. Wait 2 ns for response. */ while (!done && receiveTimeout (0.seconds, (Msg m) { if (m.to in msgs) { msgs[m.to] ~= m; } else { msgs[m.to] = [m]; } }, (Act act) { switch (act) { case Act.done: // end cell processing done = true; break; default: auto s = format ( "Error in thread %s: received message Act.%s", ndx, act); writefln (s); throw new UnexpectedMessage(s); } // switch (act) } //(Act act) ) ) { } // while (!done && receiveTimeout void sendMsg (Msg m) { assert (m.to > 0); assert (m.to < lastId); int ndx = m.to % numCThreads; Tid ct = cast(Tid)cThreads[ndx]; ct.send(m); } } // void cellThread() void main() { auto cellTids = new shared(Tid)[numCThreads]; foreach (id; 0 .. numCThreads) { auto cThread = spawn(&cellThread, id, cellTids); cellTids[id] = cast(shared(Tid))cThread; } foreach (cThread; cellTids) { Tid ct = cast(Tid)cThread; ct.send(Act.done); } }
May 20 2014
parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 05/20/2014 05:24 PM, Charles Hixson via Digitalmars-d-learn wrote:

 On Tuesday, May 20, 2014 11:42:48 AM Ali Çehreli via Digitalmars-d-learn
 wrote:
 On 05/20/2014 11:38 AM, Charles Hixson via Digitalmars-d-learn wrote:
 Is it a bug that an immutable struct cannot be sent to a thread?  (It
 compiles without problem if I make all elements mutable.)
Further reduced: import std.concurrency; struct S { immutable int i; } void foo() {} void main() { auto f = spawn(&foo); auto s = S(); f.send(s); } I think this is a known issue with immutable and Variant, which std.concurrency uses for unknown messages. This looks related: https://issues.dlang.org/show_bug.cgi?id=5538 Ali
May 21 2014
next sibling parent Charles Hixson via Digitalmars-d-learn writes:
On Wednesday, May 21, 2014 01:19:32 PM Ali Çehreli via Digitalmars-d-learn 
wrote:
 On 05/20/2014 05:24 PM, Charles Hixson via Digitalmars-d-learn wrote:
  > On Tuesday, May 20, 2014 11:42:48 AM Ali Çehreli via Digitalmars-d-learn
  > 
  > wrote:
  >> On 05/20/2014 11:38 AM, Charles Hixson via Digitalmars-d-learn wrote:
  >>> Is it a bug that an immutable struct cannot be sent to a thread?  (It
  >>> compiles without problem if I make all elements mutable.)
 
 Further reduced:
 
 import std.concurrency;
 
 struct S
 {
      immutable int i;
 }
 
 void foo()
 {}
 
 void main()
 {
      auto f = spawn(&foo);
 
      auto s = S();
      f.send(s);
 }
 
 I think this is a known issue with immutable and Variant, which
 std.concurrency uses for unknown messages. This looks related:
 
    https://issues.dlang.org/show_bug.cgi?id=5538
 
 Ali
Thanks. Fortunately, I don't really need for messages to be immutable, I just thought it would be safer (as in avoiding the possibility of making a mistake). They're stucts, and I never pass a pointer, just the struct. Being immutable would allow me to guarantee that certain logic errors couldn't be committed is all.
May 21 2014
prev sibling parent "Sean Kelly" <sean invisibleduck.org> writes:
On Wednesday, 21 May 2014 at 20:19:32 UTC, Ali Çehreli wrote:
 I think this is a known issue with immutable and Variant, which 
 std.concurrency uses for unknown messages. This looks related:

   https://issues.dlang.org/show_bug.cgi?id=5538
std.concurrency actually uses Variant as the transport mechanism for all messages, and this is most likely the cause of your problem. If this is just to make a class pass type checking for transport, casting to shared is probably a better bet. The real solution is to make std.concurrency effectively allow uniquely referenced classes to be transferred, but that's a bit farther out.
May 22 2014