What Needs to be Done?

We would like to implement a data handle that can be read across multiple ranks, is efficiently cached, and exploits communication persistence to efficiently update the cache of data.

• We are imagining a data handle vt::DR<X> my_handle, where X is a user's data type that may or may not be serializable. - vt::DR<X> has reference (or move-only) semantics on a given rank.
• It can be migrated to another rank safely and it does not interfere with any reads.
• When initialized, it is given a distributed token/name that can be used to read against at a later point.

vt::Reader<X> reader = vt::DR::read<X>(TOKEN);
while (not reader.isReady()) ;
X* val = reader.get();

Under the hood, the DR will build spanning trees to distribute data efficiently and cache data as necessary.

We are thinking that the most complex part is the update protocol.

• When are updates allowed?
• How does the user sequence readers (which may be cached) with respect to an update?