| I'd never heard of ParaSail, so I found this high-level overview [1]: > All of the objects declared in a given scope are associated
with a storage region, essentially a local heap. As an object grows, all new storage
for it is allocated out of this region. As an object shrinks, the old storage can be
immediately released back to this region. When a scope is exited, the entire region is
reclaimed. There is no need for asynchronous garbage collection, as garbage never
accumulates. Objects may grow in a highly irregular fashion without losing their
locality of reference. > Note that pointers are still used behind the scenes in the ParaSail implementation,
but eliminating them from the surface syntax and semantics eliminates the complexity
associated with pointers. This approach seems to come up in many contexts, where a pointer-based address (raw pointer, reference, slice, etc.) is abstracted into a higher-level address key, usually an index integer (essentially a higher-level virtual pointer). The implementation might reallocate under the surface, or manage chunks of data through some sort of paging where the underlying pointers don't change (I was musing about this here [2]). I guess I'm thinking out loud here, but most dynamic languages (eg. Python) don't expose the pointers or care about invalidation of the addresses, they just happily reallocate. I've barely written parallelized code, is pointer aliasing really one of the biggest roadblocks? It seems like it can be abstracted away fairly easily, even in a pointer-exposing language. 1. https://www.adacore.com/uploads/papers/parasail-pointer-free... 2. https://news.ycombinator.com/item?id=49013285 |