Hi everybody,
this all sounds really great to me. Frankly, as a Fortraner it is the first time I'm reading something about Jupyter / IPython but I am eager to learn the basic concepts shortly.
My main focus is currently on atomic subroutines and the SYNC MEMORY statement. My related coarray Github repositories are still experimental, but I would suggest to consider the content of the following two main repositories (as well as the few smaller ones that are related to them):
https://github.com/MichaelSiehl/Atomic_Subroutines--How_the_Parallel_Codes_may_look_like--Part_1
https://github.com/MichaelSiehl/Atomic_Subroutines--How_the_Parallel_Codes_may_look_like--Part_2
Just a brief update:
To my current understanding, the core solution of these is very similar to the solution of the ABA problem with the Compare-And-Swap (CAS) hardware implementation for atomic operations on x86 computers. This is explained here (
https://jfdube.wordpress.com/2011/11/30/understanding-atomic-operations/ ) and here (
https://en.wikipedia.org/wiki/Compare-and-swap ).
Compared to the ABA solution, we just use an ordinary integer scalar to store an integer-based enumeration value (this is similar to the appended increment counter of the ABA solution) together with the main atomic value (which I call 'additional atomic value' in the repository's source code). The integer-based enumeration helps to make sophisticated parallel logic codes more readable, compared to a simple increment counter.
OpenCoarrays does allow to use remote atomic_define together with a single (scalar) array element of an integer array component (of a derived type coarray). (The 'remote' here is not supported by ifort 18 beta update 1 yet). With the above ABA-like solution, we can safely synchronize the value of each distinct scalar array element atomically. This might also be the promising solution for synchronizing whole integer arrays atomically. And if we can process whole integer arrays atomically (and since integer is a very general data type that can in principle be used to store anything else with it), there might be no restrictions for implementing sophisticated algorithms based entirely on atomics (and thus, with user-defined segment ordering).
cheers