Hi everybody,
this is just to shortly share information about the current status of advancing in our Coarray Fortran programming (task-based MPMD-like parallel software development in serial Fortran coding style). Hope you'll enjoy that :-)
Context: In our preparation to achieve a required degree of (dynamic) load balancing and scalability for upcoming many-core computers, we already obtain major advancing with Coarray Fortran (PGAS). Our successful setup, a Multiple Program Multiple Data (MPMD)-like programming style, seems to be rather uncommon with Fortran's Single Program Multiple Data (SPMD) coarray extension. Nevertheless, we made excellent experiences in extending an existing Fortran 95 serial-style object-based framework with coarrays.
Task-based MPMD-like parallel software development in serial Fortran coding style: The possibility to encapsulate access to the coarray syntax is due to the fact that coarrays are only a minimalistic extension to the Fortran base language. To understand, let us face the fact that parallel programming is cumbersome and does scare away most programers. To avoid coding errors in our coarray programming, we soon started to encapsulate access to the required coarray syntax and functionality into object-based wrapper objects. (Our setup is F95 object-based/ADT). Thereby, the parallel logic code can be written without coarrays, or in other words, the encapsulation enables us to do object-based parallel programming exclusively with serial Fortran syntax.
With that, the main coding does not feel much like parallel programming any more, but merely like ordinary object-based programming with the introduction of new ways of how the various objects can interact with each other. (That is through our coarray wrapper objects and because the program logic code of the various main objects gets executed simultaneously, but asynchronously, in purely local memory on the distinct images.) We are not aware of any easier way to do parallel software development. The programming isn't any different from serial programming, at least in terms of writing the program logic code.
Moreover, due to our MPMD-like programming style, build-in synchronizations are rarely required any more, because more powerful synchronization methods can easily be implemented by the programer himself using serial Fortran syntax. (That way, the synchronization methods are coded as being between objects rather than being between images). Also some main feature of the proposed Coarray TS (Fortran 2015), namely grouping images into teams, can already be implemented using Fortran 2008 coarrays. It is also an ease to designate single images to distinct tasks (task-based parallel programming). Even further, it already allows us to add parallelism dynamically to the program (from outside the code), which might be a good first stride to achieve unlimited scalability in our future work.
Conclusion and Future Work: The use of simple serial Fortran syntax for the parallel logic code makes advanced parallel software development for upcoming many-core computers feasible. The objective is to achieve scalability and dynamic load balancing through an asynchronous task-based parallel programming by means of an ISO standard. From our current view, Fortran 2008 does already meet important requirements of what is called an APGAS (or High Productivity Computing Systems) programming language. Others may argue. It is our aim to build a small sample program to show the simple techniques in practice.
cheers
Michael