consultancygasil.blogg.se - Berkeley upc shared array block

#Berkeley upc shared array block mod#

John and I already discussed this further in person, so just recording additional points here. Readonly permits us to cache and replicate each rank's value across all peers (unscalable for small scale), or just some log(N) peers (scalable). I would like to consider breaking this out as a fundamental upcxx data structure. This collective need not be blocking, we could just roll the asynchrony of waiting for the initial all-to-all (at least just the part we need for the current lookup) into the future.Īt the heart of this data structure lies a more fundamental building block that solves the unscalable metadata problem. At large scale it would be a sparse-all-to-all in a scheme like the one Dan/Paul plan to use to make team rank translation scalable.

At small scale this would be the familiar non-scalable all-to-all that our users usually do.

Construction becomes an expensive collective to internally distribute the base pointers.

So I propose an API possibly similar to the one Dan just posted, but with the following change: This is not a dis of dist_object, which I maintain is still excellent for managing distribution when rpc's are the best communication mechanism. If we build a data structure that is inattentive-tolerant and scalable we would be offering something the rest of our library does not. Though we are caching addresses, that won't help random algorithms. I would like to investigate an alternate implementation, one not over dist_object, to remove the dependence on remote attentiveness for address lookup.

Or possibly a non-blocking version that returns global_ptr for cache hit and nullptr on cache miss.Either a "blocking" version that returns global_ptr.We may want add a version of pointer_to that avoids the future-construction overhead for the common case of cache hit.Still need to add C++ iterators for the global index space.Blocks of the array have a guaranteed layout (same as UPC) allowing well-defined construction of contiguous local views of all local elements, and alternate blocksize views over the same elements.Initial implementation may only support the default layout (Kathy’s requirement).

#Berkeley upc shared array block mod#

static blocksize may allow the other mod operation (by blocksize) in indexing to be constant-folded away or strength-reduced by the optimizer.this elides one dynamic mod operation (by ranks_n()) per indexing op.Default (0) means pure blocked, ie ceil ( count / ranks_n() ).Blocksize can be provided statically (as template parameter BS) or dynamically in the constructor.1-D distributed array with arbitrary blocksize.Gives us the option to change our mind and deploy a completely different distributed array interface later.Does not rely upon UPC++ internals, can be written by any competent UPC++ programmer.Written as a contrib library atop UPC++, in a different namespace.