www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Issue calling methods using std.concurrency

reply "Casey" <sybrandy gmail.com> writes:
Hello,

I'm getting some errors when I wrap a struct that I've written 
with another struct.  Here are the errors I'm getting:

tqueue.d(14): Error: function queue.Queue!(int).Queue.enqueue 
(int value) is not
  callable using argument types (int) shared
tqueue.d(15): Error: function queue.Queue!(int).Queue.dequeue () 
is not callable
  using argument types ()

Here's the receive block which the issue:

receive(
     (T value) { queue.enqueue(value); },
     (Tid caller) { send(caller, queue.dequeue); }
);

The queue itself is shared.  Outside of that, nothing special 
going on.  I just have a class that I want to be able to in a 
concurrent environment without having to modify the original 
class.

Any thoughts?
Apr 22 2012
parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 04/22/2012 07:15 PM, Casey wrote:

 Hello,

 I'm getting some errors when I wrap a struct that I've written with
 another struct. Here are the errors I'm getting:

 tqueue.d(14): Error: function queue.Queue!(int).Queue.enqueue (int
 value) is not
 callable using argument types (int) shared
 tqueue.d(15): Error: function queue.Queue!(int).Queue.dequeue () is not
 callable
 using argument types ()

 Here's the receive block which the issue:

 receive(
 (T value) { queue.enqueue(value); },
 (Tid caller) { send(caller, queue.dequeue); }
 );

 The queue itself is shared. Outside of that, nothing special going on. I
 just have a class that I want to be able to in a concurrent environment
 without having to modify the original class.

 Any thoughts?


This works at least with 2.059 on 64-bit Linux:

import std.stdio;
import std.concurrency;
import core.thread;

class Foo
{
     int i;
}

void workerFunc(Tid owner)
{
     receive(
         (shared(Foo) foo) {
             writeln("Before: ", foo.i);
             foo.i = 42;
         });

     owner.send(42);
}

void main (string[] args)
{
     shared foo = new shared(Foo);

     auto worker = spawn(&workerFunc, thisTid);
     worker.send(foo);
     receiveOnly!int();
     writeln("After: ", foo.i);
}

The output:

Before: 0
After: 42

Ali
Apr 22 2012
parent reply "Casey" <sybrandy gmail.com> writes:
On Monday, 23 April 2012 at 02:34:19 UTC, Ali Çehreli wrote:

 This works at least with 2.059 on 64-bit Linux:

 import std.stdio;
 import std.concurrency;
 import core.thread;

 class Foo
 {
     int i;
 }

 void workerFunc(Tid owner)
 {
     receive(
         (shared(Foo) foo) {
             writeln("Before: ", foo.i);
             foo.i = 42;
         });

     owner.send(42);
 }

 void main (string[] args)
 {
     shared foo = new shared(Foo);

     auto worker = spawn(&workerFunc, thisTid);
     worker.send(foo);
     receiveOnly!int();
     writeln("After: ", foo.i);
 }

 The output:

 Before: 0
 After: 42

 Ali


Ali,

I actually did print out the value being passed successfully.  
It's just that when I used the queue methods (enqueue and 
dequeue), it get this error.  The queue itself is shared, but 
none of the methods are expecting a shared value nor do I believe 
they should.

Casey
Apr 23 2012
next sibling parent =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 04/23/2012 11:44 AM, Casey wrote:


 I actually did print out the value being passed successfully. It's just
 that when I used the queue methods (enqueue and dequeue), it get this
 error. The queue itself is shared, but none of the methods are expecting
 a shared value nor do I believe they should.

 Casey


Could you please show a short program having the same problem. I am not 
familiar with enqueue or dequeue.

Ali
Apr 23 2012
prev sibling parent reply "Stanislav Blinov" <stanislav.blinov gmail.com> writes:
On Monday, 23 April 2012 at 18:44:37 UTC, Casey wrote:

 I actually did print out the value being passed successfully.  
 It's just that when I used the queue methods (enqueue and 
 dequeue), it get this error.  The queue itself is shared, but 
 none of the methods are expecting a shared value nor do I 
 believe they should.


 From what I can gather from error messages, you have a shared 
reference to a non-shared class:

---

class Queue {
     void enqueue(int v) { /*...*/ }
     int dequeue() { /*...*/ }
}

// ...

auto queue = new shared(Queue);

// ...

---

If that is the case, then it's not that the methods are expecting 
a shared value, it's that methods are not 'expecting' a shared 
'this'. And indeed there is what seems to be a quirk in the 
design of 'shared' in that it won't allow such calls. But it is 
actually not a quirk, but means for the compiler to discard 
incorrect code. If you want your methods to be called for shared 
reference, the whole your class or at least those methods should 
be shared as well. Just like with const: if you have a const 
reference, you can only call const methods.

Whenever you encounter such issue, you should carefully think 
about what's going on. If the class you use is not designed to be 
shared, you shouldn't just start calling its methods from 
different threads, since it is by definition not safe, no matter 
what its documentation may state (remember, shared is there to 
enforce such guarantees). If it is actually made thread-safe 
(via, e.g. synchronized blocks), then the reference really 
shouldn't be shared.

All that said, your best bets are either to rethink your design 
(do you really need a shared queue if you are using message 
passing anyway?), or to provide an implementation for shared 
queue. If anything, consider that shared queue is very different 
from non-shared one: are you satisfied with locking queue, or do 
you need lockless one? Is your queue mostly read or written 
thread-wise, or maybe it's only one provider and one consumer? 
I'm sure experts in asynchronous programming can provide a dozen 
more questions that should be answered and then coded into the 
implementation of a queue that you want to share among threads.

I understand the desire to have one neat implementation that 
'just works', no matter the conditions, but unfortunately, with 
asynchronous programming that is not an option.
Apr 23 2012
parent "Casey" <sybrandy gmail.com> writes:
Stanislav: I think you just hit the nail on the head with the 
shared reference to this.  I didn't even think of that as the 
error message made me think of the parameter being shared.

As for solving it, I'll have to think about it.  I was hoping to 
just have a single queue class (Or any other in the future) that 
worked well single-threaded, but could be used in a 
multi-threaded environment if I used std.concurrency properly.  
Essentially, my goal was to have only a single queue, but use 
message passing to enqueue/dequeue items from the queue without 
having to create a custom thread-safe queue class.

Well, I guess I have to rethink what I'm doing.  Thanks!
Apr 25 2012