allow immediate return from collective subroutines

[brandongc]

This is analogous to the widely used immediate (or non-blocking) collectives in MPI.

type(event_type) :: a
call co_sum(x, event = a) ! "Immediate return" like MPI_Iallreduce
call do_something_independent(y)
event wait (a) ! can't use x until co_sum is done

Benefits:

• Avoid opportunity for some deadlocks
• Performance: overlap computation with communication
• Easier to replace MPI with Fortran

[rouson]

Presumably this will inspire us to remove the requirement that objects of event_type must be coarrays, which is constraint C1604 in the Fortran 2018 standard.

[ThemosTsikas]

I am thinking that this could generalize to any CALL statement with the introduction of the syntax

CALL [ ( call-control-spec-list ) ] procedure-designator [ ( [ actual-arg-spec-list ] ) ] call-control-spec is [ EVENT = ] event-variable

There will be a need for a new intrinsic function (CALL?) with no arguments whose return value is the event-variable (or a pointer associated with it?) of the currently executing CALL.

This is just musing. Do you know of any work on similar ideas?

[everythingfunctional]

There will be a need for a new intrinsic function (CALL?) with no arguments whose return value is the event-variable (or a pointer associated with it?) of the currently executing CALL.

Can you elaborate on this? I'm not sure I'm following. Couldn't there be multiple currently executing "calls"? I.e.

type(event_type) :: a, b
call co_sum(x, event=a)
call co_sum(y, event=b)
! Do something independent of x and y
event wait (a)
! do something with x
event wait (b)
! do something with y

This is just musing. Do you know of any work on similar ideas?

https://github.com/jeffhammond/j3/blob/main/asynchronous_tasks.md is possibly related.

[ThemosTsikas]

type(event_type) :: a, b
call (EVENT=a) process(x)
call (EVENT=b) process(y)
! Do something independent of x and y
event wait (a)
! do something with x
event wait (b)
! do something with y

During execution of "process(x)"/"process(y)", the intrinsic function "CALL()" returns a/b, respectively.

[everythingfunctional]

Interesting idea. Does that imply

• only subroutines can be executed asynchronously
• only subroutines can reference the new intrinsic CALL function (I might give that a different name)
• any subroutines that do reference the new intrinsic function must be called with an event variable?

[FortranFan]

• new intrinsic CALL function (I might give that a different name)

You mean CALL statement?

Re: "different name" - CO_CALL? !!!: :-))

[ThemosTsikas]

block-stmt is [ block-construct-name : ] BLOCK [ ( call-control-spec-list )

if you must!

Instead of an intrinsic function, an intrinsic subroutine would allow for EVENT= and STAT= arguments, to handle the case where no event has been associated by the executing BLOCK or SUBROUTINE.