| 1 |
/* { dg-do compile } */ |
| 2 |
/* { dg-additional-options "-std=c99" { target c } } */ |
| 3 |
|
| 4 |
typedef enum omp_allocator_handle_t |
| 5 |
#if __cplusplus >= 201103L |
| 6 |
: __UINTPTR_TYPE__ |
| 7 |
#endif |
| 8 |
{ |
| 9 |
omp_null_allocator = 0, |
| 10 |
omp_default_mem_alloc = 1, |
| 11 |
omp_large_cap_mem_alloc = 2, |
| 12 |
omp_const_mem_alloc = 3, |
| 13 |
omp_high_bw_mem_alloc = 4, |
| 14 |
omp_low_lat_mem_alloc = 5, |
| 15 |
omp_cgroup_mem_alloc = 6, |
| 16 |
omp_pteam_mem_alloc = 7, |
| 17 |
omp_thread_mem_alloc = 8, |
| 18 |
__omp_allocator_handle_t_max__ = __UINTPTR_MAX__ |
| 19 |
} omp_allocator_handle_t; |
| 20 |
|
| 21 |
typedef enum omp_sync_hint_t { |
| 22 |
omp_sync_hint_none = 0x0, |
| 23 |
omp_lock_hint_none = omp_sync_hint_none, |
| 24 |
omp_sync_hint_uncontended = 0x1, |
| 25 |
omp_lock_hint_uncontended = omp_sync_hint_uncontended, |
| 26 |
omp_sync_hint_contended = 0x2, |
| 27 |
omp_lock_hint_contended = omp_sync_hint_contended, |
| 28 |
omp_sync_hint_nonspeculative = 0x4, |
| 29 |
omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative, |
| 30 |
omp_sync_hint_speculative = 0x8, |
| 31 |
omp_lock_hint_speculative = omp_sync_hint_speculative |
| 32 |
} omp_sync_hint_t; |
| 33 |
|
| 34 |
typedef struct __attribute__((__aligned__ (sizeof (void *)))) omp_depend_t { |
| 35 |
char __omp_depend_t__[2 * sizeof (void *)]; |
| 36 |
} omp_depend_t; |
| 37 |
|
| 38 |
int t; |
| 39 |
#pragma omp threadprivate (t) |
| 40 |
|
| 41 |
#pragma omp declare target |
| 42 |
int f, l, ll, r, r2; |
| 43 |
|
| 44 |
void |
| 45 |
foo (int d, int m, int i1, int i2, int p, int *idp, int s, |
| 46 |
int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm) |
| 47 |
{ |
| 48 |
#pragma omp distribute parallel for, \ |
| 49 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 50 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 51 |
lastprivate (l), schedule(static, 4), order(concurrent), allocate (omp_default_mem_alloc:f) |
| 52 |
for (int i = 0; i < 64; i++) |
| 53 |
ll++; |
| 54 |
#pragma omp distribute parallel for simd, \ |
| 55 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 56 |
if (parallel: i2), if(simd: i1), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 57 |
lastprivate (l), schedule(static, 4), nontemporal(ntm), \ |
| 58 |
safelen(8), simdlen(4), aligned(q: 32), order(concurrent), allocate (omp_default_mem_alloc:f) |
| 59 |
for (int i = 0; i < 64; i++) |
| 60 |
ll++; |
| 61 |
#pragma omp distribute simd, \ |
| 62 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 63 |
safelen(8), simdlen(4), aligned(q: 32), reduction(+:r), if(i1), nontemporal(ntm), \ |
| 64 |
order(concurrent), allocate (omp_default_mem_alloc:f) |
| 65 |
for (int i = 0; i < 64; i++) |
| 66 |
ll++; |
| 67 |
} |
| 68 |
|
| 69 |
void |
| 70 |
qux (int p) |
| 71 |
{ |
| 72 |
#pragma omp loop, bind(teams), order(concurrent), \ |
| 73 |
private (p), lastprivate (l), collapse(1), reduction(+:r) |
| 74 |
for (l = 0; l < 64; ++l) |
| 75 |
ll++; |
| 76 |
} |
| 77 |
#pragma omp end declare target |
| 78 |
|
| 79 |
void |
| 80 |
baz (int d, int m, int i1, int i2, int p, int *idp, int s, |
| 81 |
int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm) |
| 82 |
{ |
| 83 |
#pragma omp distribute parallel for, \ |
| 84 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 85 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 86 |
lastprivate (l), schedule(static, 4), copyin(t), allocate (p) |
| 87 |
for (int i = 0; i < 64; i++) |
| 88 |
ll++; |
| 89 |
#pragma omp distribute parallel for, \ |
| 90 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 91 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 92 |
lastprivate (l), schedule(static, 4), order(concurrent), allocate (p) |
| 93 |
for (int i = 0; i < 64; i++) |
| 94 |
ll++; |
| 95 |
#pragma omp distribute parallel for simd, \ |
| 96 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 97 |
if (parallel: i2), if(simd: i1), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 98 |
lastprivate (l), schedule(static, 4), nontemporal(ntm), \ |
| 99 |
safelen(8), simdlen(4), aligned(q: 32), copyin(t), allocate (f) |
| 100 |
for (int i = 0; i < 64; i++) |
| 101 |
ll++; |
| 102 |
#pragma omp distribute parallel for simd, \ |
| 103 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 104 |
if (parallel: i2), if(simd: i1), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 105 |
lastprivate (l), schedule(static, 4), nontemporal(ntm), \ |
| 106 |
safelen(8), simdlen(4), aligned(q: 32), order(concurrent), allocate (f) |
| 107 |
for (int i = 0; i < 64; i++) |
| 108 |
ll++; |
| 109 |
#pragma omp distribute simd, \ |
| 110 |
private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \ |
| 111 |
safelen(8), simdlen(4), aligned(q: 32), reduction(+:r), if(i1), nontemporal(ntm), \ |
| 112 |
order(concurrent), allocate (f) |
| 113 |
for (int i = 0; i < 64; i++) |
| 114 |
ll++; |
| 115 |
#pragma omp loop, bind(parallel), order(concurrent), \ |
| 116 |
private (p), lastprivate (l), collapse(1), reduction(+:r) |
| 117 |
for (l = 0; l < 64; ++l) |
| 118 |
ll++; |
| 119 |
} |
| 120 |
|
| 121 |
void |
| 122 |
bar (int d, int m, int i1, int i2, int i3, int p, int *idp, int hda, int s, |
| 123 |
int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int *dd, int ntm, |
| 124 |
int n1, int n2) |
| 125 |
{ |
| 126 |
#pragma omp for simd, \ |
| 127 |
private (p), firstprivate (f), lastprivate (l), linear (ll:1), reduction(+:r), schedule(static, 4), collapse(1), nowait, \ |
| 128 |
safelen(8), simdlen(4), aligned(q: 32), nontemporal(ntm), if(i1), order(concurrent), allocate (f) |
| 129 |
for (int i = 0; i < 64; i++) |
| 130 |
ll++; |
| 131 |
#pragma omp parallel for, \ |
| 132 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 133 |
lastprivate (l), linear (ll:1), ordered, schedule(static, 4), collapse(1), allocate (f) |
| 134 |
for (int i = 0; i < 64; i++) |
| 135 |
ll++; |
| 136 |
#pragma omp parallel for, \ |
| 137 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 138 |
lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), order(concurrent), allocate (f) |
| 139 |
for (int i = 0; i < 64; i++) |
| 140 |
ll++; |
| 141 |
#pragma omp parallel for simd, \ |
| 142 |
private (p), firstprivate (f), if (i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 143 |
lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), \ |
| 144 |
safelen(8), simdlen(4), aligned(q: 32), nontemporal(ntm), order(concurrent), allocate (f) |
| 145 |
for (int i = 0; i < 64; i++) |
| 146 |
ll++; |
| 147 |
#pragma omp parallel sections, \ |
| 148 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 149 |
lastprivate (l), allocate (f) |
| 150 |
{ |
| 151 |
#pragma omp section |
| 152 |
{} |
| 153 |
#pragma omp section |
| 154 |
{} |
| 155 |
} |
| 156 |
#pragma omp target parallel, \ |
| 157 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 158 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 159 |
nowait, depend(inout: dd[0]), allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 160 |
; |
| 161 |
#pragma omp target parallel for, \ |
| 162 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 163 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 164 |
lastprivate (l), linear (ll:1), ordered, schedule(static, 4), collapse(1), nowait, depend(inout: dd[0]), \ |
| 165 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 166 |
for (int i = 0; i < 64; i++) |
| 167 |
ll++; |
| 168 |
#pragma omp target parallel for, \ |
| 169 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 170 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 171 |
lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), nowait, depend(inout: dd[0]), order(concurrent), \ |
| 172 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 173 |
for (int i = 0; i < 64; i++) |
| 174 |
ll++; |
| 175 |
#pragma omp target parallel for simd, \ |
| 176 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 177 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 178 |
lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), \ |
| 179 |
safelen(8), simdlen(4), aligned(q: 32), nowait, depend(inout: dd[0]), nontemporal(ntm), if (simd: i3), order(concurrent), \ |
| 180 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 181 |
for (int i = 0; i < 64; i++) |
| 182 |
ll++; |
| 183 |
#pragma omp target teams, \ |
| 184 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 185 |
shared(s), default(shared), reduction(+:r), num_teams(nte - 1:nte), thread_limit(tl), nowait depend(inout: dd[0]), \ |
| 186 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 187 |
; |
| 188 |
#pragma omp target teams distribute, \ |
| 189 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 190 |
shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), order(concurrent), \ |
| 191 |
collapse(1), dist_schedule(static, 16), nowait, depend(inout: dd[0]), allocate (omp_default_mem_alloc:f), in_reduction(+:r2), \ |
| 192 |
has_device_addr(hda) |
| 193 |
for (int i = 0; i < 64; i++) |
| 194 |
; |
| 195 |
#pragma omp target teams distribute parallel for, \ |
| 196 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 197 |
shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 198 |
collapse(1), dist_schedule(static, 16), \ |
| 199 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 200 |
lastprivate (l), schedule(static, 4), nowait, depend(inout: dd[0]), order(concurrent), \ |
| 201 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 202 |
for (int i = 0; i < 64; i++) |
| 203 |
ll++; |
| 204 |
#pragma omp target teams distribute parallel for simd, \ |
| 205 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 206 |
shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 207 |
collapse(1), dist_schedule(static, 16), \ |
| 208 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 209 |
lastprivate (l), schedule(static, 4), order(concurrent), \ |
| 210 |
safelen(8), simdlen(4), aligned(q: 32), nowait, depend(inout: dd[0]), nontemporal(ntm), if (simd: i3), \ |
| 211 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 212 |
for (int i = 0; i < 64; i++) |
| 213 |
ll++; |
| 214 |
#pragma omp target teams distribute simd, \ |
| 215 |
device(d), map (tofrom: m), if (i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 216 |
shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 217 |
collapse(1), dist_schedule(static, 16), order(concurrent), \ |
| 218 |
safelen(8), simdlen(4), aligned(q: 32), nowait depend(inout: dd[0]), nontemporal(ntm), \ |
| 219 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 220 |
for (int i = 0; i < 64; i++) |
| 221 |
ll++; |
| 222 |
#pragma omp target simd, \ |
| 223 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 224 |
safelen(8), simdlen(4), lastprivate (l), linear(ll: 1), aligned(q: 32), reduction(+:r), \ |
| 225 |
nowait depend(inout: dd[0]), nontemporal(ntm), if(simd:i3), order(concurrent), \ |
| 226 |
allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda) |
| 227 |
for (int i = 0; i < 64; i++) |
| 228 |
ll++; |
| 229 |
#pragma omp taskgroup, task_reduction(+:r2), allocate (r2) |
| 230 |
#pragma omp taskloop simd, \ |
| 231 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \ |
| 232 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \ |
| 233 |
order(concurrent), allocate (f) |
| 234 |
for (int i = 0; i < 64; i++) |
| 235 |
ll++; |
| 236 |
#pragma omp taskgroup, task_reduction(+:r), allocate (r) |
| 237 |
#pragma omp taskloop simd, \ |
| 238 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(i1), final(fi), mergeable, nogroup, priority (pp), \ |
| 239 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), in_reduction(+:r), nontemporal(ntm), \ |
| 240 |
order(concurrent), allocate (f) |
| 241 |
for (int i = 0; i < 64; i++) |
| 242 |
ll++; |
| 243 |
#pragma omp taskwait |
| 244 |
#pragma omp taskloop simd, \ |
| 245 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), if(taskloop: i1), final(fi), priority (pp), \ |
| 246 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(+:r), if (simd: i3), nontemporal(ntm), \ |
| 247 |
order(concurrent), allocate (f) |
| 248 |
for (int i = 0; i < 64; i++) |
| 249 |
ll++; |
| 250 |
#pragma omp target, nowait, depend(inout: dd[0]), in_reduction(+:r2) |
| 251 |
#pragma omp teams distribute, \ |
| 252 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 253 |
collapse(1), dist_schedule(static, 16), allocate (omp_default_mem_alloc: f), order(concurrent) |
| 254 |
for (int i = 0; i < 64; i++) |
| 255 |
; |
| 256 |
#pragma omp target |
| 257 |
#pragma omp teams distribute parallel for, \ |
| 258 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 259 |
collapse(1), dist_schedule(static, 16), \ |
| 260 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 261 |
lastprivate (l), schedule(static, 4), order(concurrent), allocate (omp_default_mem_alloc: f) |
| 262 |
for (int i = 0; i < 64; i++) |
| 263 |
ll++; |
| 264 |
#pragma omp target |
| 265 |
#pragma omp teams distribute parallel for simd, \ |
| 266 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 267 |
collapse(1), dist_schedule(static, 16), \ |
| 268 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 269 |
lastprivate (l), schedule(static, 4), order(concurrent), \ |
| 270 |
safelen(8), simdlen(4), aligned(q: 32), if (simd: i3), nontemporal(ntm), \ |
| 271 |
allocate (omp_default_mem_alloc: f) |
| 272 |
for (int i = 0; i < 64; i++) |
| 273 |
ll++; |
| 274 |
#pragma omp target |
| 275 |
#pragma omp teams distribute simd, \ |
| 276 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 277 |
collapse(1), dist_schedule(static, 16), order(concurrent), \ |
| 278 |
safelen(8), simdlen(4), aligned(q: 32), if(i3), nontemporal(ntm), \ |
| 279 |
allocate (omp_default_mem_alloc: f) |
| 280 |
for (int i = 0; i < 64; i++) |
| 281 |
ll++; |
| 282 |
#pragma omp teams distribute parallel for, \ |
| 283 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 284 |
collapse(1), dist_schedule(static, 16), \ |
| 285 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 286 |
lastprivate (l), schedule(static, 4), copyin(t), allocate (f) |
| 287 |
for (int i = 0; i < 64; i++) |
| 288 |
ll++; |
| 289 |
#pragma omp teams distribute parallel for, \ |
| 290 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 291 |
collapse(1), dist_schedule(static, 16), order(concurrent), \ |
| 292 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 293 |
lastprivate (l), schedule(static, 4), allocate (f) |
| 294 |
for (int i = 0; i < 64; i++) |
| 295 |
ll++; |
| 296 |
#pragma omp teams distribute parallel for simd, \ |
| 297 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 298 |
collapse(1), dist_schedule(static, 16), \ |
| 299 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 300 |
lastprivate (l), schedule(static, 4), \ |
| 301 |
safelen(8), simdlen(4), aligned(q: 32), if (simd: i3), nontemporal(ntm), copyin(t), \ |
| 302 |
allocate (f) |
| 303 |
for (int i = 0; i < 64; i++) |
| 304 |
ll++; |
| 305 |
#pragma omp teams distribute parallel for simd, \ |
| 306 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 307 |
collapse(1), dist_schedule(static, 16), \ |
| 308 |
if (parallel: i2), num_threads (nth), proc_bind(spread), \ |
| 309 |
lastprivate (l), schedule(static, 4), order(concurrent), \ |
| 310 |
safelen(8), simdlen(4), aligned(q: 32), if (simd: i3), nontemporal(ntm), \ |
| 311 |
allocate (f) |
| 312 |
for (int i = 0; i < 64; i++) |
| 313 |
ll++; |
| 314 |
#pragma omp teams distribute simd, \ |
| 315 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 316 |
collapse(1), dist_schedule(static, 16), order(concurrent), \ |
| 317 |
safelen(8), simdlen(4), aligned(q: 32), if(i3), nontemporal(ntm), allocate(f) |
| 318 |
for (int i = 0; i < 64; i++) |
| 319 |
ll++; |
| 320 |
#pragma omp parallel master, \ |
| 321 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), reduction(+:r), \ |
| 322 |
num_threads (nth), proc_bind(spread), copyin(t), allocate (f) |
| 323 |
; |
| 324 |
#pragma omp parallel masked, \ |
| 325 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), reduction(+:r), \ |
| 326 |
num_threads (nth), proc_bind(spread), copyin(t), allocate (f), filter (d) |
| 327 |
; |
| 328 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 329 |
#pragma omp master taskloop, \ |
| 330 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \ |
| 331 |
reduction(default, +:r), in_reduction(+:r2), allocate (f) |
| 332 |
for (int i = 0; i < 64; i++) |
| 333 |
ll++; |
| 334 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 335 |
#pragma omp masked taskloop, \ |
| 336 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \ |
| 337 |
reduction(default, +:r), in_reduction(+:r2), allocate (f), filter (d) |
| 338 |
for (int i = 0; i < 64; i++) |
| 339 |
ll++; |
| 340 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 341 |
#pragma omp master taskloop simd, \ |
| 342 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \ |
| 343 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \ |
| 344 |
order(concurrent), allocate (f) |
| 345 |
for (int i = 0; i < 64; i++) |
| 346 |
ll++; |
| 347 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 348 |
#pragma omp masked taskloop simd, \ |
| 349 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \ |
| 350 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \ |
| 351 |
order(concurrent), allocate (f), filter (d) |
| 352 |
for (int i = 0; i < 64; i++) |
| 353 |
ll++; |
| 354 |
#pragma omp parallel master taskloop, \ |
| 355 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \ |
| 356 |
reduction(default, +:r), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), allocate (f) |
| 357 |
for (int i = 0; i < 64; i++) |
| 358 |
ll++; |
| 359 |
#pragma omp parallel masked taskloop, \ |
| 360 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \ |
| 361 |
reduction(default, +:r), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), allocate (f), filter (d) |
| 362 |
for (int i = 0; i < 64; i++) |
| 363 |
ll++; |
| 364 |
#pragma omp parallel master taskloop simd, \ |
| 365 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \ |
| 366 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), \ |
| 367 |
order(concurrent), allocate (f) |
| 368 |
for (int i = 0; i < 64; i++) |
| 369 |
ll++; |
| 370 |
#pragma omp parallel masked taskloop simd, \ |
| 371 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \ |
| 372 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), \ |
| 373 |
order(concurrent), allocate (f), filter (d) |
| 374 |
for (int i = 0; i < 64; i++) |
| 375 |
ll++; |
| 376 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 377 |
#pragma omp master taskloop, \ |
| 378 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 379 |
reduction(default, +:r), in_reduction(+:r2) |
| 380 |
for (int i = 0; i < 64; i++) |
| 381 |
ll++; |
| 382 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 383 |
#pragma omp mastked taskloop, \ |
| 384 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 385 |
reduction(default, +:r), in_reduction(+:r2), filter (d) |
| 386 |
for (int i = 0; i < 64; i++) |
| 387 |
ll++; |
| 388 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 389 |
#pragma omp master taskloop simd, \ |
| 390 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 391 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \ |
| 392 |
order(concurrent), allocate (f) |
| 393 |
for (int i = 0; i < 64; i++) |
| 394 |
ll++; |
| 395 |
#pragma omp taskgroup, task_reduction (+:r2), allocate (r2) |
| 396 |
#pragma omp masked taskloop simd, \ |
| 397 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 398 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \ |
| 399 |
order(concurrent), allocate (f), filter (d) |
| 400 |
for (int i = 0; i < 64; i++) |
| 401 |
ll++; |
| 402 |
#pragma omp parallel master taskloop, \ |
| 403 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 404 |
reduction(default, +:r), num_threads (nth), proc_bind(spread), copyin(t), allocate (f) |
| 405 |
for (int i = 0; i < 64; i++) |
| 406 |
ll++; |
| 407 |
#pragma omp parallel masked taskloop, \ |
| 408 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 409 |
reduction(default, +:r), num_threads (nth), proc_bind(spread), copyin(t), allocate (f), filter (d) |
| 410 |
for (int i = 0; i < 64; i++) |
| 411 |
ll++; |
| 412 |
#pragma omp parallel master taskloop simd, \ |
| 413 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 414 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), num_threads (nth), proc_bind(spread), copyin(t), \ |
| 415 |
order(concurrent), allocate (f) |
| 416 |
for (int i = 0; i < 64; i++) |
| 417 |
ll++; |
| 418 |
#pragma omp parallel masked taskloop simd, \ |
| 419 |
private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \ |
| 420 |
safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), num_threads (nth), proc_bind(spread), copyin(t), \ |
| 421 |
order(concurrent), allocate (f), filter (d) |
| 422 |
for (int i = 0; i < 64; i++) |
| 423 |
ll++; |
| 424 |
#pragma omp loop, bind(thread), order(concurrent), \ |
| 425 |
private (p), lastprivate (l), collapse(1), reduction(+:r) |
| 426 |
for (l = 0; l < 64; ++l) |
| 427 |
ll++; |
| 428 |
#pragma omp parallel loop, \ |
| 429 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 430 |
lastprivate (l), collapse(1), bind(parallel), order(concurrent), allocate (f) |
| 431 |
for (l = 0; l < 64; l++) |
| 432 |
ll++; |
| 433 |
#pragma omp parallel loop, \ |
| 434 |
private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 435 |
lastprivate (l), collapse(1), allocate (f) |
| 436 |
for (l = 0; l < 64; l++) |
| 437 |
ll++; |
| 438 |
#pragma omp teams loop, \ |
| 439 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \ |
| 440 |
collapse(1), lastprivate (l), bind(teams), allocate (f) |
| 441 |
for (l = 0; l < 64; ++l) |
| 442 |
; |
| 443 |
#pragma omp teams loop, \ |
| 444 |
private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \ |
| 445 |
collapse(1), lastprivate (l), order(concurrent), allocate (f) |
| 446 |
for (l = 0; l < 64; ++l) |
| 447 |
; |
| 448 |
#pragma omp target parallel loop, \ |
| 449 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 450 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 451 |
nowait depend(inout: dd[0]), lastprivate (l), bind(parallel), order(concurrent), collapse(1), \ |
| 452 |
allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda) |
| 453 |
for (l = 0; l < 64; ++l) |
| 454 |
; |
| 455 |
#pragma omp target parallel loop, \ |
| 456 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 457 |
if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \ |
| 458 |
nowait depend(inout: dd[0]), lastprivate (l), order(concurrent), collapse(1), \ |
| 459 |
allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda) |
| 460 |
for (l = 0; l < 64; ++l) |
| 461 |
; |
| 462 |
#pragma omp target teams loop, \ |
| 463 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 464 |
shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), nowait depend(inout: dd[0]), \ |
| 465 |
lastprivate (l), bind(teams), collapse(1), \ |
| 466 |
allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda) |
| 467 |
for (l = 0; l < 64; ++l) |
| 468 |
; |
| 469 |
#pragma omp target teams loop, \ |
| 470 |
device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \ |
| 471 |
shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), nowait depend(inout: dd[0]), \ |
| 472 |
lastprivate (l), order(concurrent), collapse(1), \ |
| 473 |
allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda) |
| 474 |
for (l = 0; l < 64; ++l) |
| 475 |
; |
| 476 |
#pragma omp critical |
| 477 |
; |
| 478 |
#pragma omp critical (foobar),hint(omp_sync_hint_none) |
| 479 |
; |
| 480 |
#pragma omp taskwait, depend (inout: dd[0]) |
| 481 |
; |
| 482 |
#pragma omp taskgroup, task_reduction(+:r2),allocate (r2) |
| 483 |
; |
| 484 |
#pragma omp atomic, update,seq_cst,hint(omp_sync_hint_none) |
| 485 |
p++; |
| 486 |
#pragma omp atomic, read, hint(omp_sync_hint_none),relaxed |
| 487 |
f = p; |
| 488 |
#pragma omp atomic,write, release hint(omp_sync_hint_none) |
| 489 |
p = f; |
| 490 |
#pragma omp flush |
| 491 |
; |
| 492 |
#pragma omp flush, acq_rel |
| 493 |
; |
| 494 |
#pragma omp flush, acquire |
| 495 |
; |
| 496 |
#pragma omp flush, release |
| 497 |
; |
| 498 |
#pragma omp flush, seq_cst |
| 499 |
; |
| 500 |
#pragma omp flush (p, f) |
| 501 |
; |
| 502 |
#pragma omp simd, \ |
| 503 |
private (p),lastprivate (l),linear (ll:1),reduction(+:r),collapse(1),safelen(8),simdlen(4),aligned(q: 32), \ |
| 504 |
nontemporal(ntm),if(i1) |
| 505 |
for (int i = 0; i < 64; i++) |
| 506 |
#pragma omp ordered, simd |
| 507 |
ll++; |
| 508 |
#pragma omp for, \ |
| 509 |
private (p),firstprivate (f),lastprivate (l),linear (ll:1),reduction(+:r),schedule(static, 4),collapse(1),nowait, \ |
| 510 |
ordered, allocate (f) |
| 511 |
for (int i = 0; i < 64; i++) |
| 512 |
#pragma omp ordered, threads |
| 513 |
ll++; |
| 514 |
#pragma omp for, ordered (1) |
| 515 |
for (l = 0; l < 64; l++) |
| 516 |
{ |
| 517 |
#pragma omp ordered, depend (sink: l - 1) |
| 518 |
; |
| 519 |
#pragma omp ordered, depend (source) |
| 520 |
; |
| 521 |
} |
| 522 |
extern omp_depend_t depobj; |
| 523 |
#pragma omp depobj(depobj),depend(in : dd[0]) |
| 524 |
; |
| 525 |
#pragma omp parallel |
| 526 |
{ |
| 527 |
if (p) { |
| 528 |
#pragma omp cancel, parallel |
| 529 |
; |
| 530 |
} else { |
| 531 |
#pragma omp cancellation point, parallel |
| 532 |
; |
| 533 |
} |
| 534 |
} |
| 535 |
#pragma omp scope, private (p), firstprivate (f), reduction(+:r), nowait, \ |
| 536 |
allocate(omp_default_mem_alloc: r) |
| 537 |
; |
| 538 |
#pragma omp scope, private (p), firstprivate (f), reduction(task, +:r), \ |
| 539 |
allocate (omp_default_mem_alloc: f) |
| 540 |
; |
| 541 |
extern int t2; |
| 542 |
#pragma omp threadprivate (t2) |
| 543 |
extern int t2; |
| 544 |
#pragma omp declare reduction (dr: int: omp_out += omp_in),initializer (omp_priv = 0) |
| 545 |
#pragma omp assume, no_openmp, no_openmp_routines, no_parallelism, \ |
| 546 |
absent (atomic, barrier, cancel, cancellation point), \ |
| 547 |
absent (critical, depobj), \ |
| 548 |
absent (distribute, flush, loop, masked, master, nothing, ordered), \ |
| 549 |
absent (parallel, scan, scope, section, sections, simd, single, task), \ |
| 550 |
absent (taskgroup, taskloop, taskwait, taskyield), \ |
| 551 |
absent (target, teams, for, error), holds (n1 < n2) |
| 552 |
if (0) |
| 553 |
; |
| 554 |
#pragma omp assume, contains (simd) |
| 555 |
#pragma omp for simd |
| 556 |
for (int i = 0; i < 64; i++) |
| 557 |
; |
| 558 |
} |
| 559 |
|
| 560 |
void corge1 (); |
| 561 |
|
| 562 |
void |
| 563 |
corge () |
| 564 |
{ |
| 565 |
#pragma omp declare variant (corge1),match (construct={parallel,for}) |
| 566 |
extern void corge2 (); |
| 567 |
#pragma omp parallel |
| 568 |
#pragma omp for |
| 569 |
for (int i = 0; i < 5; i++) |
| 570 |
corge2 (); |
| 571 |
#pragma omp declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch |
| 572 |
#pragma omp declare simd,simdlen(8),notinbranch |
| 573 |
extern int corge3 (int l, int *p); |
| 574 |
#pragma omp declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch |
| 575 |
#pragma omp declare simd, simdlen(8),notinbranch |
| 576 |
extern int corge4 (int l, int *p); |
| 577 |
#pragma omp declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch |
| 578 |
#pragma omp declare simd, simdlen(8),notinbranch |
| 579 |
extern int corge5 (int l, int *p); |
| 580 |
#pragma omp declare target |
| 581 |
extern void corge6 (); |
| 582 |
#pragma omp end declare target |
| 583 |
} |
| 584 |
|
| 585 |
int |
| 586 |
garply (int a, int *c, int *d, int *e, int *f) |
| 587 |
{ |
| 588 |
int i; |
| 589 |
#pragma omp simd, reduction (inscan, +: a) |
| 590 |
for (i = 0; i < 64; i++) |
| 591 |
{ |
| 592 |
d[i] = a; |
| 593 |
#pragma omp scan, exclusive (a) |
| 594 |
a += c[i]; |
| 595 |
} |
| 596 |
#pragma omp simd, reduction (inscan, +: a) |
| 597 |
for (i = 0; i < 64; i++) |
| 598 |
{ |
| 599 |
a += c[i]; |
| 600 |
#pragma omp scan inclusive (a) |
| 601 |
d[i] = a; |
| 602 |
} |
| 603 |
return a; |
| 604 |
} |