Lines Matching full:that

29 Actions that obviously can't be executed in parallel or that
32 * Control flow statements that would prevent the loop nest from
34   `GOTO` or `CYCLE` that leaves the construct.
37 * Calling a procedure that is not `PURE`.
38 * Deallocation of any polymorphic entity, as that could cause
46 compile into code that exploits the parallel features of the target
50 But it turns out that these rules, though *necessary* for safe parallel
52 One may write conforming `DO CONCURRENT` constructs that cannot
61 concurrent construct, or even as a construct that imposes sufficient
72 multiple iterations of the loop so long as its only reads from that
86 The scalar variable `TMP` is used in this loop in a way that conforms
87 to the standard, as every use of `TMP` follows a definition that appears
90 The idea, of course, is that a parallelizing compiler isn't required to
93 This means that the loop can be internally rewritten as if it had been
107 The automatic localization rules of `DO CONCURRENT` that allow
111 in cases that a compiler cannot determine exactly due to
159 The programmer may know that they are so, but a compiler
161 that they are so.
183 However, a compiler can't be sure that the pure function `F`
188 construct with a sheaf of constraints that we assume are intended
191 with the addition of an automatic localization rule that provides
195 1. prove that automatic localization *is* required for a given
197 1. prove that automatic localization *isn't* required in any iteration.
204 `SHARED`, overriding the automatic localization rule so that it
207 `LOCAL` variables are those that can be defined by more than one
210 `SHARED` variables are those that, if defined in
213 (There is also a `LOCAL_INIT` specifier that is not relevant to the
214 problem at hand, and a `DEFAULT(NONE)` specifier that requires a
223 (like the scalar `T` in `MODULE M` above) that are not local variables
228 within an iteration that a compiler must make anyway.
253 In the example above that defines `T(IX(J))` and reads from `T(IY(J))`,
255 that are modified at most once and localize the cases where
274 Programmers writing `DO CONCURRENT` loops that are safely parallelizable
275 need an effective means to convey to compilers that those compilers
279 Specifically, an easy means is required that stipulates that localization
286    by which one can inform the compiler that it should localize only
294 1. Assume that these stronger conditions hold by default, and add a command-line
297    in the event that the program contains one of those inherently
298    non-parallelizable `DO CONCURRENT` loops that perhaps should never have
303    But this option could lead to non-standard behavior for codes that depend,
306    parallelization that can be done, and refer dissatisfied users to J3.
310 The best option seems to be the one that assumes that users who write
315 As of August 2020, we observe that the GNU Fortran compiler (10.1) does not
322 When OpenMP is enabled, ifort reports that all `DO CONCURRENT` constructs are