Located resources

[gebner]

• loc_id is a logical location from which you can observe memory, on l p says that p is true at location l, locations can be e.g.:
  • a thread (i.e., on thrid (x |-> y) means that when thread number thrid reads the variable x it will reliably get y)
  • global memory
  • global memory on a GPU
• every thread is associated with a process (which is also a location), there can be multiple processes
  • every block in a GPU kernel is logically a process
  • we can axiomatize when it is safe to move resources between blocks/devices/processes
• slprops are stratified according to how easy it is to move them between locations:
  • placeless p means you can unconditionally move them anywhere, e.g., pure, inv, on, ghost references, etc.
  • is_send p means you can move them to threads of the same process
• invariants require placeless slprops, fork requires is_send, mutex requires is_send

To check out the interface, a good place to look is the diff for Pulse.Lib.Core.fsti and Pulse.Lib.Send.fsti.

Pain points:

• Trades, sigh. We already have two versions of trades with different restrictions on the closure: trade and shift (which requires the closure to be duplicable). This approach would add a lot of other useful restrictions to the mix: sending a trade across threads requires an is_sync closure, sending a trade across devices requires a placeless closure, pulling a trade out of a later requires a timeless closure, etc. Obviously, some might want a duplicable+timeless+is_sync trade too... You can work around this a bit with on, but I foresee a plethora of trade variants.
• You need to write a lot of placeless/is_send/is_sync instances; they're usually trivial though.

Fun points:

• Using type classes for placeless/is_send/is_sync seems to work out nicely; or at least nicer than the SMT pattern setup for timeless.

[tahina-pro]

Shouldn't we also add a "located" version of par allowing to run from a user-specified location and spawn a thread in a separate user-specified location?

[gebner]

You can easily simulate that with impersonate.