looping

Provides convenience macros for shared-memory-parallel loops

module variable that we can access by giving fully-qualified name in loop macros

module variable used to store LoopRanges that are swapped into the loopranges variable in begin*_region() functions

LoopRanges structs contain information on which points should be included on this process in loops over shared-memory arrays.

Members

paralleldims::Tuple{Vararg{Symbol}} Indicates which dimensions are (or might be) parallelized when using this LoopRanges. Provided for information for developers, to make it easier to tell (when using a Debugger, or printing debug informatino) which LoopRanges instance is active in looping.loopranges at any point in the code. rank0::Bool Is this process the one with rank 0 in the 'block' which work in parallel on shared memory arrays. <d>::UnitRange{mkint} Loop ranges for each dimension <d> in looping.alldimensions.

Begin 'anyv' sub-region in which () velocity space dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the beginanyv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _anyv_subblock_synchronize() to synchronize the processes operating on an 'anyv' shared-memory sub-block, unless no_synchronize=true is passed as an argument.

Begin 'anyv' sub-region in which (:vpa,) velocity space dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the beginanyv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _anyv_subblock_synchronize() to synchronize the processes operating on an 'anyv' shared-memory sub-block, unless no_synchronize=true is passed as an argument.

Begin 'anyv' sub-region in which (:vperp,) velocity space dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the beginanyv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _anyv_subblock_synchronize() to synchronize the processes operating on an 'anyv' shared-memory sub-block, unless no_synchronize=true is passed as an argument.

Begin 'anyv' sub-region in which (:vperp, :vpa) velocity space dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the beginanyv*region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _anyv_subblock_synchronize() to synchronize the processes operating on an 'anyv' shared-memory sub-block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:r, :z, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s,:r,:z) dimensions and velocity dimensions are parallelized by being split between processes, and which velocity dimensions are parallelized can be switched within the outer loop over (:s,:r,:z). This parallelization scheme is intended for use in the collision operator.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :z) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :z, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :z, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :r, :z, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :z) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :z, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :z, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:s, :z, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which only rank-0 in each group of processes operating on a shared-memory block operates on shared-memory arrays.

Returns immediately if loopranges[] is already set for a serial region. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :r, :z, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:sn, :z, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vpa,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vperp,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vr,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vz,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vzeta,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z,) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vperp) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vperp, :vpa) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vzeta) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vzeta, :vr) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vzeta, :vr, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

Begin region in which (:z, :vzeta, :vz) dimensions are parallelized by being split between processes.

Returns immediately if loopranges[] is already set to the parallel dimensions being requested. This allows the begin*_region() calls to be placed where they make logical sense, with no cost if a call happens to be repeated (e.g. in different functions).

Calls _block_synchronize() to synchronize the processes operating on a shared-memory block, unless no_synchronize=true is passed as an argument.

For debugging the shared-memory parallelism, create ranges where only the loops for a single combinations of variables (given by combination_to_split) are parallelised, and which dimensions are parallelised can be set with the dims_to_split... arguments.

Arguments

Keyword arguments dim=n are required for each dim in all_dimensions where n is an integer giving the size of the dimension.

Construct a string composed of the dimension names given in the Tuple dims, separated by underscores

Find the numbers of processes for each dimension that optimize load balance for 'anyv' type loops for a certain block_size.

The 'anyv' parallelisation patterns are designed for use in the collision operator. They all share the same parallelisation in species and spatial dimensions so that the region type can be switched between 'anyv' types within a loop over species and spatial dimensions (@loopsr_z). It is only defined for ions, not for neutrals.

Parts of the collision operator cannot conveniently be parallelised over velocity dimensions, so this function aims to assign as much parallelism as possible to the species and spatial dimensions.

Find the ranges for loop variables that optimize load balance for a certain block_size

Get local range of indices when splitting a loop over processes in a sub-block

Calculate the maximum number of grid points on any process

This is a measure of the maximum amount of work to do on a single process. Minimising this will make the parallelisation as efficient as possible.

Arguments

nprocslist : Vector{mkint} Number of processes for each dimension sizes : Vector{mk_int} Size of each dimension

Find possible divisions of each number less than or equal to block_size into n factors.

Find possible divisions of subblocksize into n factors

Create ranges for loops with different combinations of variables

Arguments

Keyword arguments dim=n are required for each dim in [:s, :r, :z, :vperp, :vpa, :sn, :vzeta, :vr, :vz] where n is an integer giving the size of the dimension.

Run a block of code on only anyv-subblock-rank-0 of each group of processes operating on an 'anyv' shared-memory subblock

Loop over (:r,) dimensions

Loop over (:r, :vpa) dimensions

Loop over (:r, :vperp) dimensions

Loop over (:r, :vperp, :vpa) dimensions

Loop over (:r, :vr) dimensions

Loop over (:r, :vr, :vz) dimensions

Loop over (:r, :vz) dimensions

Loop over (:r, :vzeta) dimensions

Loop over (:r, :vzeta, :vr) dimensions

Loop over (:r, :vzeta, :vr, :vz) dimensions

Loop over (:r, :vzeta, :vz) dimensions

Loop over (:r, :z) dimensions

Loop over (:r, :z, :vpa) dimensions

Loop over (:r, :z, :vperp) dimensions

Loop over (:r, :z, :vperp, :vpa) dimensions

Loop over (:r, :z, :vr) dimensions

Loop over (:r, :z, :vr, :vz) dimensions

Loop over (:r, :z, :vz) dimensions

Loop over (:r, :z, :vzeta) dimensions

Loop over (:r, :z, :vzeta, :vr) dimensions

Loop over (:r, :z, :vzeta, :vr, :vz) dimensions

Loop over (:r, :z, :vzeta, :vz) dimensions

Loop over (:s,) dimensions

Loop over (:s, :r) dimensions

Loop over (:s, :r, :vpa) dimensions

Loop over (:s, :r, :vperp) dimensions

Loop over (:s, :r, :vperp, :vpa) dimensions

Loop over (:s, :r, :z) dimensions

Loop over (:s, :r, :z, :vpa) dimensions

Loop over (:s, :r, :z, :vperp) dimensions

Loop over (:s, :r, :z, :vperp, :vpa) dimensions

Loop over (:s, :vpa) dimensions

Loop over (:s, :vperp) dimensions

Loop over (:s, :vperp, :vpa) dimensions

Loop over (:s, :z) dimensions

Loop over (:s, :z, :vpa) dimensions

Loop over (:s, :z, :vperp) dimensions

Loop over (:s, :z, :vperp, :vpa) dimensions

Loop over (:sn,) dimensions

Loop over (:sn, :r) dimensions

Loop over (:sn, :r, :vr) dimensions

Loop over (:sn, :r, :vr, :vz) dimensions

Loop over (:sn, :r, :vz) dimensions

Loop over (:sn, :r, :vzeta) dimensions

Loop over (:sn, :r, :vzeta, :vr) dimensions

Loop over (:sn, :r, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :r, :vzeta, :vz) dimensions

Loop over (:sn, :r, :z) dimensions

Loop over (:sn, :r, :z, :vr) dimensions

Loop over (:sn, :r, :z, :vr, :vz) dimensions

Loop over (:sn, :r, :z, :vz) dimensions

Loop over (:sn, :r, :z, :vzeta) dimensions

Loop over (:sn, :r, :z, :vzeta, :vr) dimensions

Loop over (:sn, :r, :z, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :r, :z, :vzeta, :vz) dimensions

Loop over (:sn, :vr) dimensions

Loop over (:sn, :vr, :vz) dimensions

Loop over (:sn, :vz) dimensions

Loop over (:sn, :vzeta) dimensions

Loop over (:sn, :vzeta, :vr) dimensions

Loop over (:sn, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :vzeta, :vz) dimensions

Loop over (:sn, :z) dimensions

Loop over (:sn, :z, :vr) dimensions

Loop over (:sn, :z, :vr, :vz) dimensions

Loop over (:sn, :z, :vz) dimensions

Loop over (:sn, :z, :vzeta) dimensions

Loop over (:sn, :z, :vzeta, :vr) dimensions

Loop over (:sn, :z, :vzeta, :vr, :vz) dimensions

Loop over (:sn, :z, :vzeta, :vz) dimensions

Loop over (:vpa,) dimensions

Loop over (:vperp,) dimensions

Loop over (:vperp, :vpa) dimensions

Loop over (:vr,) dimensions

Loop over (:vr, :vz) dimensions

Loop over (:vz,) dimensions

Loop over (:vzeta,) dimensions

Loop over (:vzeta, :vr) dimensions

Loop over (:vzeta, :vr, :vz) dimensions

Loop over (:vzeta, :vz) dimensions

Loop over (:z,) dimensions

Loop over (:z, :vpa) dimensions

Loop over (:z, :vperp) dimensions

Loop over (:z, :vperp, :vpa) dimensions

Loop over (:z, :vr) dimensions

Loop over (:z, :vr, :vz) dimensions

Loop over (:z, :vz) dimensions

Loop over (:z, :vzeta) dimensions

Loop over (:z, :vzeta, :vr) dimensions

Loop over (:z, :vzeta, :vr, :vz) dimensions

Loop over (:z, :vzeta, :vz) dimensions

Run a block of code on only rank-0 of each group of processes operating on a shared-memory block