problem to use Mutex. about grappa

[nelsonje]

Delegate operations can't contain blocking code---the lock() call may block. You can wrap it in a spawn() call to spawn a new task, which will be able to block.

[bholt]

There's also the version of call that takes a Mutex of some sort and creates a heap-allocated continuation if it has to block: https://github.com/uwsampa/grappa/blob/master/system/Delegate.hpp#L159

I can't find any instances where it was used. I think I planned to use it in GlobalVector, but ended up manually using SuspendedDelegate: https://github.com/uwsampa/grappa/blob/master/system/GlobalVector.hpp#L146

We do have an alternate version of call that creates a task so it can be suspended, but as the documentation for that method indicates, this can be a problem because there's a chance of running out of workers, leading to deadlock (which happened frequently whenever I tried spawning dependent tasks inside of other tasks), so I encourage you to tread very lightly there.

[septicmk]

@bholt could you show me a example how to use the version of call that takes a Mutex to try lock on remote mutex? I am confused about the way this functions works after reading the code.
Actually, I just want a function that lock( GlobalAddress<Mutex> m ) does, but I found that I can't use this function to lock on remote mutex since there is just a CHECK(false).
https://github.com/uwsampa/grappa/blob/master/system/Mutex.hpp#L106

[bholt]

It's definitely pretty wonky. I meant to wrap it in some nicer functions but never got around to it. It was intended to be as general-purpose as possible, so it takes 2 lambdas: one lambda is like a delegate, but its only purpose is to return a pointer to the Mutex that you want to lock/wait on. Then, when the mutex is unlocked, the second lambda parameter will get invoked, which should probably lock the mutex. But due to me being lazy a long time ago, you also have to return something non-void. So, long story short, I think this should work to do a remote lock as a blocking delegate:

GlobalAddress<Mutex> mptr = /* get global address somehow */;
bool result = delegate::call(mptr.core(),
  // runs on remote node; computes local pointer to mutex
  // (in this case just getting the pointer component of the
  // GlobalAddress, but could be whatever you want)
  [mptr]{ return mptr.pointer(); },
  // runs once the mutex is unlocked; should probably lock it,
  // but then you can also do whatever other work you want,
  // such as returning a value from this remote node. 
  // in this case I just return "true" (have to return something)
  [](Mutex* m){
    lock(m);
    return true;
  });

(caveat: I haven't tested this beyond making sure it compiles)

[septicmk]

So, this function must return something non-void? Now I know how to deal with my remote mutex, Thank you!