From 4d49018b5e838a58f2565f69a7b1cdd58eb7d40d Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 1 Oct 2021 20:00:00 +0200 Subject: [PATCH] openmp: Differentiate between order(concurrent) and order(reproducible:concurrent) While OpenMP 5.1 implies order(concurrent) is the same thing as order(reproducible:concurrent), this is going to change in OpenMP 5.2, where essentially order(concurrent) means nothing is stated on whether it is reproducible or unconstrained (and is determined by other means, e.g. for/do with schedule static or runtime with static being selected is implicitly reproducible, distribute with dist_schedule static is implicitly reproducible, loop is implicitly reproducible) and when the modifier is specified explicitly, it overrides the implicit behavior either way. And, when order(reproducible:concurrent) is used with e.g. schedule(dynamic) or some other schedule that is by definition not reproducible, it is implementation's duty to ensure it is reproducible, either by remembering how it scheduled some loop and then replaying the same schedule when seeing loops with the same directive/schedule/number of iterations, or by overriding the schedule to some reproducible one. This patch doesn't implement the 5.2 wording just yet, but in the FEs differentiates between the 3 states - no explicit modifier, explicit reproducible or explicit unconstrainted, so that the middle-end can easily switch any time. Instead it follows the 5.1 wording where both order(concurrent) (implicit or explicit) or order(reproducible:concurrent) imply reproducibility. And, it implements the easier method, when for/do should be reproducible, it just chooses static schedule. order(concurrent) implies no OpenMP APIs in the loop body nor threadprivate vars, so the exact scheduling isn't (easily at least) observable. 2021-10-01 Jakub Jelinek gcc/ * tree.h (OMP_CLAUSE_ORDER_REPRODUCIBLE): Define. * tree-pretty-print.c (dump_omp_clause) : Print reproducible: for OMP_CLAUSE_ORDER_REPRODUCIBLE. * omp-general.c (omp_extract_for_data): If OMP_CLAUSE_ORDER is seen without OMP_CLAUSE_ORDER_UNCONSTRAINED, overwrite sched_kind to OMP_CLAUSE_SCHEDULE_STATIC. gcc/c-family/ * c-omp.c (c_omp_split_clauses): Also copy OMP_CLAUSE_ORDER_REPRODUCIBLE. gcc/c/ * c-parser.c (c_parser_omp_clause_order): Set OMP_CLAUSE_ORDER_REPRODUCIBLE for explicit reproducible: modifier. gcc/cp/ * parser.c (cp_parser_omp_clause_order): Set OMP_CLAUSE_ORDER_REPRODUCIBLE for explicit reproducible: modifier. gcc/fortran/ * gfortran.h (gfc_omp_clauses): Add order_reproducible bitfield. * dump-parse-tree.c (show_omp_clauses): Print REPRODUCIBLE: for it. * openmp.c (gfc_match_omp_clauses): Set order_reproducible for explicit reproducible: modifier. * trans-openmp.c (gfc_trans_omp_clauses): Set OMP_CLAUSE_ORDER_REPRODUCIBLE for order_reproducible. (gfc_split_omp_clauses): Also copy order_reproducible. gcc/testsuite/ * gfortran.dg/gomp/order-5.f90: Adjust scan-tree-dump-times regexps. libgomp/ * testsuite/libgomp.c-c++-common/order-reproducible-1.c: New test. * testsuite/libgomp.c-c++-common/order-reproducible-2.c: New test. (cherry picked from commit e705b8533aa0a00a65734eb5fd6344295723dccc) --- gcc/ChangeLog.omp | 12 ++++ gcc/c-family/ChangeLog.omp | 8 +++ gcc/c-family/c-omp.c | 4 ++ gcc/c/ChangeLog.omp | 8 +++ gcc/c/c-parser.c | 6 +- gcc/cp/ChangeLog.omp | 8 +++ gcc/cp/parser.c | 6 +- gcc/fortran/ChangeLog.omp | 13 ++++ gcc/fortran/dump-parse-tree.c | 2 + gcc/fortran/gfortran.h | 4 +- gcc/fortran/openmp.c | 5 +- gcc/fortran/trans-openmp.c | 7 +++ gcc/omp-general.c | 16 +++++ gcc/testsuite/ChangeLog.omp | 7 +++ gcc/testsuite/gfortran.dg/gomp/order-5.f90 | 8 +-- gcc/tree-pretty-print.c | 2 + gcc/tree.h | 3 + libgomp/ChangeLog.omp | 8 +++ .../order-reproducible-1.c | 63 +++++++++++++++++++ .../order-reproducible-2.c | 28 +++++++++ 20 files changed, 208 insertions(+), 10 deletions(-) create mode 100644 libgomp/testsuite/libgomp.c-c++-common/order-reproducible-1.c create mode 100644 libgomp/testsuite/libgomp.c-c++-common/order-reproducible-2.c diff --git a/gcc/ChangeLog.omp b/gcc/ChangeLog.omp index ec76feb28294..c69454167c0a 100644 --- a/gcc/ChangeLog.omp +++ b/gcc/ChangeLog.omp @@ -1,3 +1,15 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * tree.h (OMP_CLAUSE_ORDER_REPRODUCIBLE): Define. + * tree-pretty-print.c (dump_omp_clause) : Print + reproducible: for OMP_CLAUSE_ORDER_REPRODUCIBLE. + * omp-general.c (omp_extract_for_data): If OMP_CLAUSE_ORDER is seen + without OMP_CLAUSE_ORDER_UNCONSTRAINED, overwrite sched_kind to + OMP_CLAUSE_SCHEDULE_STATIC. + 2021-09-30 Tobias Burnus Backported from master: diff --git a/gcc/c-family/ChangeLog.omp b/gcc/c-family/ChangeLog.omp index 7a8616e7ee6a..afb871f6d82a 100644 --- a/gcc/c-family/ChangeLog.omp +++ b/gcc/c-family/ChangeLog.omp @@ -1,3 +1,11 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * c-omp.c (c_omp_split_clauses): Also copy + OMP_CLAUSE_ORDER_REPRODUCIBLE. + 2021-09-22 Tobias Burnus Backported from master: diff --git a/gcc/c-family/c-omp.c b/gcc/c-family/c-omp.c index 5669718a0bd3..fa07738b7455 100644 --- a/gcc/c-family/c-omp.c +++ b/gcc/c-family/c-omp.c @@ -2273,6 +2273,8 @@ c_omp_split_clauses (location_t loc, enum tree_code code, OMP_CLAUSE_ORDER); OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = OMP_CLAUSE_ORDER_UNCONSTRAINED (clauses); + OMP_CLAUSE_ORDER_REPRODUCIBLE (c) + = OMP_CLAUSE_ORDER_REPRODUCIBLE (clauses); OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE]; cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE] = c; } @@ -2284,6 +2286,8 @@ c_omp_split_clauses (location_t loc, enum tree_code code, OMP_CLAUSE_ORDER); OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = OMP_CLAUSE_ORDER_UNCONSTRAINED (clauses); + OMP_CLAUSE_ORDER_REPRODUCIBLE (c) + = OMP_CLAUSE_ORDER_REPRODUCIBLE (clauses); OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_FOR]; cclauses[C_OMP_CLAUSE_SPLIT_FOR] = c; s = C_OMP_CLAUSE_SPLIT_SIMD; diff --git a/gcc/c/ChangeLog.omp b/gcc/c/ChangeLog.omp index 434d5adeb661..bd47ba3160ff 100644 --- a/gcc/c/ChangeLog.omp +++ b/gcc/c/ChangeLog.omp @@ -1,3 +1,11 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * c-parser.c (c_parser_omp_clause_order): Set + OMP_CLAUSE_ORDER_REPRODUCIBLE for explicit reproducible: modifier. + 2021-09-22 Tobias Burnus Backported from master: diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index ebec1305f79b..367fb2fc04bf 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -14642,6 +14642,7 @@ c_parser_omp_clause_order (c_parser *parser, tree list) tree c; const char *p; bool unconstrained = false; + bool reproducible = false; matching_parens parens; if (!parens.require_open (parser)) @@ -14652,7 +14653,9 @@ c_parser_omp_clause_order (c_parser *parser, tree list) p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); if (strcmp (p, "unconstrained") == 0) unconstrained = true; - else if (strcmp (p, "reproducible") != 0) + else if (strcmp (p, "reproducible") == 0) + reproducible = true; + else { c_parser_error (parser, "expected % or " "%"); @@ -14677,6 +14680,7 @@ c_parser_omp_clause_order (c_parser *parser, tree list) check_no_duplicate_clause (list, OMP_CLAUSE_ORDER, "order"); c = build_omp_clause (loc, OMP_CLAUSE_ORDER); OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = unconstrained; + OMP_CLAUSE_ORDER_REPRODUCIBLE (c) = reproducible; OMP_CLAUSE_CHAIN (c) = list; return c; diff --git a/gcc/cp/ChangeLog.omp b/gcc/cp/ChangeLog.omp index f75271fcccb1..06b5dc933026 100644 --- a/gcc/cp/ChangeLog.omp +++ b/gcc/cp/ChangeLog.omp @@ -1,3 +1,11 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * parser.c (cp_parser_omp_clause_order): Set + OMP_CLAUSE_ORDER_REPRODUCIBLE for explicit reproducible: modifier. + 2021-09-23 Tobias Burnus 2021-09-23 Jakub Jelinek diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 58d4625dbf9f..954f85d4b2d5 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -37500,6 +37500,7 @@ cp_parser_omp_clause_order (cp_parser *parser, tree list, location_t location) tree c, id; const char *p; bool unconstrained = false; + bool reproducible = false; matching_parens parens; if (!parens.require_open (parser)) @@ -37512,7 +37513,9 @@ cp_parser_omp_clause_order (cp_parser *parser, tree list, location_t location) p = IDENTIFIER_POINTER (id); if (strcmp (p, "unconstrained") == 0) unconstrained = true; - else if (strcmp (p, "reproducible") != 0) + else if (strcmp (p, "reproducible") == 0) + reproducible = true; + else { cp_parser_error (parser, "expected % or " "%"); @@ -37543,6 +37546,7 @@ cp_parser_omp_clause_order (cp_parser *parser, tree list, location_t location) check_no_duplicate_clause (list, OMP_CLAUSE_ORDER, "order", location); c = build_omp_clause (location, OMP_CLAUSE_ORDER); OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = unconstrained; + OMP_CLAUSE_ORDER_REPRODUCIBLE (c) = reproducible; OMP_CLAUSE_CHAIN (c) = list; return c; diff --git a/gcc/fortran/ChangeLog.omp b/gcc/fortran/ChangeLog.omp index 9a1995ba8f10..3e65e177e755 100644 --- a/gcc/fortran/ChangeLog.omp +++ b/gcc/fortran/ChangeLog.omp @@ -1,3 +1,16 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * gfortran.h (gfc_omp_clauses): Add order_reproducible bitfield. + * dump-parse-tree.c (show_omp_clauses): Print REPRODUCIBLE: for it. + * openmp.c (gfc_match_omp_clauses): Set order_reproducible for + explicit reproducible: modifier. + * trans-openmp.c (gfc_trans_omp_clauses): Set + OMP_CLAUSE_ORDER_REPRODUCIBLE for order_reproducible. + (gfc_split_omp_clauses): Also copy order_reproducible. + 2021-09-30 Tobias Burnus Backported from master: diff --git a/gcc/fortran/dump-parse-tree.c b/gcc/fortran/dump-parse-tree.c index 61b6dbe4fad0..f7b74f78e463 100644 --- a/gcc/fortran/dump-parse-tree.c +++ b/gcc/fortran/dump-parse-tree.c @@ -1632,6 +1632,8 @@ show_omp_clauses (gfc_omp_clauses *omp_clauses) fputs (" ORDER(", dumpfile); if (omp_clauses->order_unconstrained) fputs ("UNCONSTRAINED:", dumpfile); + else if (omp_clauses->order_reproducible) + fputs ("REPRODUCIBLE:", dumpfile); fputs ("CONCURRENT)", dumpfile); } if (omp_clauses->ordered) diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 48e20811b351..be11da62d2a6 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -1493,8 +1493,8 @@ typedef struct gfc_omp_clauses unsigned inbranch:1, notinbranch:1, nogroup:1; unsigned sched_simd:1, sched_monotonic:1, sched_nonmonotonic:1; unsigned simd:1, threads:1, depend_source:1, destroy:1, order_concurrent:1; - unsigned order_unconstrained:1, capture:1, grainsize_strict:1; - unsigned num_tasks_strict:1; + unsigned order_unconstrained:1, order_reproducible:1, capture:1; + unsigned grainsize_strict:1, num_tasks_strict:1; ENUM_BITFIELD (gfc_omp_sched_kind) sched_kind:3; ENUM_BITFIELD (gfc_omp_device_type) device_type:2; ENUM_BITFIELD (gfc_omp_memorder) memorder:3; diff --git a/gcc/fortran/openmp.c b/gcc/fortran/openmp.c index 44bfdfe68f27..0cf9872bf7a7 100644 --- a/gcc/fortran/openmp.c +++ b/gcc/fortran/openmp.c @@ -2388,8 +2388,9 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, { if (m == MATCH_ERROR) goto error; - if (gfc_match (" reproducible : concurrent )") == MATCH_YES - || gfc_match (" concurrent )") == MATCH_YES) + if (gfc_match (" reproducible : concurrent )") == MATCH_YES) + c->order_reproducible = true; + else if (gfc_match (" concurrent )") == MATCH_YES) ; else if (gfc_match (" unconstrained : concurrent )") == MATCH_YES) c->order_unconstrained = true; diff --git a/gcc/fortran/trans-openmp.c b/gcc/fortran/trans-openmp.c index 0ad87fd1539e..5d2b9916893e 100644 --- a/gcc/fortran/trans-openmp.c +++ b/gcc/fortran/trans-openmp.c @@ -3829,6 +3829,7 @@ gfc_trans_omp_clauses (stmtblock_t *block, gfc_omp_clauses *clauses, { c = build_omp_clause (gfc_get_location (&where), OMP_CLAUSE_ORDER); OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = clauses->order_unconstrained; + OMP_CLAUSE_ORDER_REPRODUCIBLE (c) = clauses->order_reproducible; omp_clauses = gfc_trans_add_clause (c, omp_clauses); } @@ -5932,6 +5933,8 @@ gfc_split_omp_clauses (gfc_code *code, = code->ext.omp_clauses->order_concurrent; clausesa[GFC_OMP_SPLIT_DISTRIBUTE].order_unconstrained = code->ext.omp_clauses->order_unconstrained; + clausesa[GFC_OMP_SPLIT_DISTRIBUTE].order_reproducible + = code->ext.omp_clauses->order_reproducible; } if (mask & GFC_OMP_MASK_PARALLEL) { @@ -5988,6 +5991,8 @@ gfc_split_omp_clauses (gfc_code *code, = code->ext.omp_clauses->order_concurrent; clausesa[GFC_OMP_SPLIT_DO].order_unconstrained = code->ext.omp_clauses->order_unconstrained; + clausesa[GFC_OMP_SPLIT_DO].order_reproducible + = code->ext.omp_clauses->order_reproducible; } if (mask & GFC_OMP_MASK_SIMD) { @@ -6006,6 +6011,8 @@ gfc_split_omp_clauses (gfc_code *code, = code->ext.omp_clauses->order_concurrent; clausesa[GFC_OMP_SPLIT_SIMD].order_unconstrained = code->ext.omp_clauses->order_unconstrained; + clausesa[GFC_OMP_SPLIT_SIMD].order_reproducible + = code->ext.omp_clauses->order_reproducible; /* And this is copied to all. */ clausesa[GFC_OMP_SPLIT_SIMD].if_expr = code->ext.omp_clauses->if_expr; diff --git a/gcc/omp-general.c b/gcc/omp-general.c index b9cd78bdeb05..127e68792583 100644 --- a/gcc/omp-general.c +++ b/gcc/omp-general.c @@ -192,6 +192,7 @@ omp_extract_for_data (gomp_for *for_stmt, struct omp_for_data *fd, == GF_OMP_FOR_KIND_DISTRIBUTE; bool taskloop = gimple_omp_for_kind (for_stmt) == GF_OMP_FOR_KIND_TASKLOOP; + bool order_reproducible = false; tree iterv, countv; fd->for_stmt = for_stmt; @@ -276,10 +277,25 @@ omp_extract_for_data (gomp_for *for_stmt, struct omp_for_data *fd, && !OMP_CLAUSE__SCANTEMP__CONTROL (t)) fd->have_nonctrl_scantemp = true; break; + case OMP_CLAUSE_ORDER: + /* FIXME: For OpenMP 5.2 this should change to + if (OMP_CLAUSE_ORDER_REPRODUCIBLE (t)) + (with the exception of loop construct but that lowers to + no schedule/dist_schedule clauses currently). */ + if (!OMP_CLAUSE_ORDER_UNCONSTRAINED (t)) + order_reproducible = true; default: break; } + /* For order(reproducible:concurrent) schedule ({dynamic,guided,runtime}) + we have either the option to expensively remember at runtime how we've + distributed work from first loop and reuse that in following loops with + the same number of iterations and schedule, or just force static schedule. + OpenMP API calls etc. aren't allowed in order(concurrent) bodies so + users can't observe it easily anyway. */ + if (order_reproducible) + fd->sched_kind = OMP_CLAUSE_SCHEDULE_STATIC; if (fd->collapse > 1 || fd->tiling) fd->loops = loops; else diff --git a/gcc/testsuite/ChangeLog.omp b/gcc/testsuite/ChangeLog.omp index 9991a6ed0dd3..ecf2ed8adfdb 100644 --- a/gcc/testsuite/ChangeLog.omp +++ b/gcc/testsuite/ChangeLog.omp @@ -1,3 +1,10 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * gfortran.dg/gomp/order-5.f90: Adjust scan-tree-dump-times regexps. + 2021-09-30 Tobias Burnus Backported from master: diff --git a/gcc/testsuite/gfortran.dg/gomp/order-5.f90 b/gcc/testsuite/gfortran.dg/gomp/order-5.f90 index 4d9e33642afb..0dddb968cb4e 100644 --- a/gcc/testsuite/gfortran.dg/gomp/order-5.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/order-5.f90 @@ -116,14 +116,14 @@ subroutine f4 (a) end do end -! { dg-final { scan-tree-dump-times "#pragma omp distribute order\\(concurrent\\)" 6 "original"} } +! { dg-final { scan-tree-dump-times "#pragma omp distribute order\\(reproducible:concurrent\\)" 6 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp distribute order\\(unconstrained:concurrent\\)" 6 "original"} } -! { dg-final { scan-tree-dump-times "#pragma omp for nowait order\\(concurrent\\)" 6 "original"} } +! { dg-final { scan-tree-dump-times "#pragma omp for nowait order\\(reproducible:concurrent\\)" 6 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp for nowait order\\(unconstrained:concurrent\\)" 6 "original"} } -! { dg-final { scan-tree-dump-times "#pragma omp for order\\(concurrent\\)" 2 "original"} } +! { dg-final { scan-tree-dump-times "#pragma omp for order\\(reproducible:concurrent\\)" 2 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp for order\\(unconstrained:concurrent\\)" 2 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp parallel" 12 "original"} } -! { dg-final { scan-tree-dump-times "#pragma omp simd linear\\(i:1\\) order\\(concurrent\\)" 6 "original"} } +! { dg-final { scan-tree-dump-times "#pragma omp simd linear\\(i:1\\) order\\(reproducible:concurrent\\)" 6 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp simd linear\\(i:1\\) order\\(unconstrained:concurrent\\)" 6 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp taskloop" 2 "original"} } ! { dg-final { scan-tree-dump-times "#pragma omp teams" 8 "original"} } diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index 163566beaaa8..d769cd8f07c5 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -1216,6 +1216,8 @@ dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags) pp_string (pp, "order("); if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause)) pp_string (pp, "unconstrained:"); + else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause)) + pp_string (pp, "reproducible:"); pp_string (pp, "concurrent)"); break; diff --git a/gcc/tree.h b/gcc/tree.h index f8853dfb7506..cc7716f5007b 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1728,6 +1728,9 @@ class auto_suppress_location_wrappers /* True for unconstrained modifier on order(concurrent) clause. */ #define OMP_CLAUSE_ORDER_UNCONSTRAINED(NODE) \ (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)->base.public_flag) +/* True for reproducible modifier on order(concurrent) clause. */ +#define OMP_CLAUSE_ORDER_REPRODUCIBLE(NODE) \ + TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)) #define OMP_CLAUSE_REDUCTION_CODE(NODE) \ (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ diff --git a/libgomp/ChangeLog.omp b/libgomp/ChangeLog.omp index cd59b5ed378c..6606f50f3cb2 100644 --- a/libgomp/ChangeLog.omp +++ b/libgomp/ChangeLog.omp @@ -1,3 +1,11 @@ +2021-10-01 Tobias Burnus + + Backported from master: + 2021-10-01 Jakub Jelinek + + * testsuite/libgomp.c-c++-common/order-reproducible-1.c: New test. + * testsuite/libgomp.c-c++-common/order-reproducible-2.c: New test. + 2021-10-01 Tobias Burnus Backported from master: diff --git a/libgomp/testsuite/libgomp.c-c++-common/order-reproducible-1.c b/libgomp/testsuite/libgomp.c-c++-common/order-reproducible-1.c new file mode 100644 index 000000000000..7e6968fe980e --- /dev/null +++ b/libgomp/testsuite/libgomp.c-c++-common/order-reproducible-1.c @@ -0,0 +1,63 @@ +#include +#include + +int +main () +{ + int a[128]; + #pragma omp teams num_teams(5) + { + #pragma omp loop bind(teams) + for (int i = 0; i < 128; i++) + { + a[i] = i; + if (i == 0) + usleep (20); + else if (i == 17) + usleep (40); + } + #pragma omp loop bind(teams) + for (int i = 0; i < 128; i++) + a[i] += i; + } + for (int i = 0; i < 128; i++) + if (a[i] != 2 * i) + abort (); + #pragma omp teams num_teams(5) + { + #pragma omp loop bind(teams) order(concurrent) + for (int i = 0; i < 128; i++) + { + a[i] *= 2; + if (i == 1) + usleep (20); + else if (i == 13) + usleep (40); + } + #pragma omp loop bind(teams) order(concurrent) + for (int i = 0; i < 128; i++) + a[i] += i; + } + for (int i = 0; i < 128; i++) + if (a[i] != 5 * i) + abort (); + #pragma omp teams num_teams(5) + { + #pragma omp loop bind(teams) order(reproducible:concurrent) + for (int i = 0; i < 128; i++) + { + a[i] *= 2; + if (i == 2) + usleep (20); + else if (i == 105) + usleep (40); + } + #pragma omp loop bind(teams) order(reproducible:concurrent) + for (int i = 0; i < 128; i++) + a[i] += i; + } + for (int i = 0; i < 128; i++) + if (a[i] != 11 * i) + abort (); + return 0; +} diff --git a/libgomp/testsuite/libgomp.c-c++-common/order-reproducible-2.c b/libgomp/testsuite/libgomp.c-c++-common/order-reproducible-2.c new file mode 100644 index 000000000000..c8ba658cf5ee --- /dev/null +++ b/libgomp/testsuite/libgomp.c-c++-common/order-reproducible-2.c @@ -0,0 +1,28 @@ +#include +#include + +int +main () +{ + int a[128]; + #pragma omp parallel num_threads(8) + { + #pragma omp barrier + #pragma omp for nowait schedule (dynamic, 2) order(reproducible:concurrent) + for (int i = 0; i < 128; i++) + { + a[i] = i; + if (i == 0) + usleep (20); + else if (i == 17) + usleep (40); + } + #pragma omp for nowait schedule (dynamic, 2) order(reproducible:concurrent) + for (int i = 0; i < 128; i++) + a[i] += i; + } + for (int i = 0; i < 128; i++) + if (a[i] != 2 * i) + abort (); + return 0; +} -- 2.47.2