| // { dg-do compile { target c++11 } } |
| |
| typedef enum omp_allocator_handle_t |
| : __UINTPTR_TYPE__ |
| { |
| omp_null_allocator = 0, |
| omp_default_mem_alloc = 1, |
| omp_large_cap_mem_alloc = 2, |
| omp_const_mem_alloc = 3, |
| omp_high_bw_mem_alloc = 4, |
| omp_low_lat_mem_alloc = 5, |
| omp_cgroup_mem_alloc = 6, |
| omp_pteam_mem_alloc = 7, |
| omp_thread_mem_alloc = 8, |
| __omp_allocator_handle_t_max__ = __UINTPTR_MAX__ |
| } omp_allocator_handle_t; |
| |
| typedef enum omp_sync_hint_t { |
| omp_sync_hint_none = 0x0, |
| omp_lock_hint_none = omp_sync_hint_none, |
| omp_sync_hint_uncontended = 0x1, |
| omp_lock_hint_uncontended = omp_sync_hint_uncontended, |
| omp_sync_hint_contended = 0x2, |
| omp_lock_hint_contended = omp_sync_hint_contended, |
| omp_sync_hint_nonspeculative = 0x4, |
| omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative, |
| omp_sync_hint_speculative = 0x8, |
| omp_lock_hint_speculative = omp_sync_hint_speculative |
| } omp_sync_hint_t; |
| |
| typedef struct __attribute__((__aligned__ (sizeof (void *)))) omp_depend_t { |
| char __omp_depend_t__[2 * sizeof (void *)]; |
| } omp_depend_t; |
| |
| int t; |
| #pragma omp threadprivate (t) |
| |
| #pragma omp declare target |
| int f, l, ll, r, r2; |
| |
| void |
| foo (int d, int m, int i1, int i2, int p, int *idp, int s, |
| int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm) |
| { |
| [[omp::directive (distribute parallel for |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) order(concurrent) allocate (omp_default_mem_alloc:f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute parallel for simd |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) if(simd: i1) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) nontemporal(ntm) |
| safelen(8) simdlen(4) aligned(q: 32) order(concurrent) allocate (omp_default_mem_alloc:f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute simd |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| safelen(8) simdlen(4) aligned(q: 32) reduction(+:r) if(i1) nontemporal(ntm) |
| order(concurrent) allocate (omp_default_mem_alloc:f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| allocate (omp_default_mem_alloc:f) order(concurrent))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| } |
| |
| void |
| qux (int p) |
| { |
| [[omp::directive (loop bind(teams) order(concurrent) |
| private (p) lastprivate (l) collapse(1) reduction(+:r))]] |
| for (l = 0; l < 64; ++l) |
| ll++; |
| } |
| #pragma omp end declare target |
| |
| void |
| baz (int d, int m, int i1, int i2, int p, int *idp, int s, |
| int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm) |
| { |
| [[omp::directive (distribute parallel for |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) copyin(t) allocate (p))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute parallel for |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) order(concurrent) allocate (p))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute parallel for simd |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) if(simd: i1) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) nontemporal(ntm) |
| safelen(8) simdlen(4) aligned(q: 32) copyin(t) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute parallel for simd |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) if(simd: i1) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) nontemporal(ntm) |
| safelen(8) simdlen(4) aligned(q: 32) order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (distribute simd |
| private (p) firstprivate (f) collapse(1) dist_schedule(static, 16) |
| safelen(8) simdlen(4) aligned(q: 32) reduction(+:r) if(i1) nontemporal(ntm) |
| order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (loop bind(parallel) order(concurrent) |
| private (p) lastprivate (l) collapse(1) reduction(+:r))]] |
| for (l = 0; l < 64; ++l) |
| ll++; |
| } |
| |
| void |
| bar (int d, int m, int i1, int i2, int i3, int p, int *idp, int hda, int s, |
| int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int *dd, int ntm, |
| const char *msg, int n1, int n2) |
| { |
| [[omp::directive (nothing)]]; |
| [[omp::directive (error at (execution) severity (warning) message (msg))]]; |
| [[omp::directive (for simd |
| private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait |
| safelen(8) simdlen(4) aligned(q: 32) nontemporal(ntm) if(i1) order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (for |
| private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait |
| order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (simd |
| private (p) lastprivate (l) linear (ll:1) reduction(+:r) collapse(1) safelen(8) simdlen(4) aligned(q: 32) |
| nontemporal(ntm) if(i1) order(concurrent))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel for |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) linear (ll:1) ordered schedule(static, 4) collapse(1) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel for |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel for simd |
| private (p) firstprivate (f) if (i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) |
| safelen(8) simdlen(4) aligned(q: 32) nontemporal(ntm) order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel sections |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) allocate (f))]] |
| { |
| [[omp::directive (section)]] |
| {} |
| [[omp::sequence (omp::directive (section))]] |
| {} |
| } |
| [[omp::directive (sections private (p) firstprivate (f) reduction(+:r) lastprivate (l) allocate (f) nowait)]] |
| { |
| ; |
| [[omp::sequence (sequence (directive (section)))]] |
| ; |
| [[omp::directive (section)]] |
| {} |
| } |
| [[omp::directive (barrier)]]; |
| [[omp::sequence (omp::directive (single private (p) firstprivate (f) allocate (f) nowait))]] |
| ; |
| [[omp::sequence (directive (barrier))]]; |
| [[omp::sequence (directive (parallel private (p)), |
| omp::directive (single copyprivate (p) firstprivate (f) allocate (f)))]] |
| p = 6; |
| [[omp::directive (target parallel |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| nowait depend(inout: dd[0]) allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| ; |
| [[omp::directive (target parallel for |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) linear (ll:1) ordered schedule(static, 4) collapse(1) nowait depend(inout: dd[0]) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (target parallel for |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) nowait depend(inout: dd[0]) order(concurrent) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (omp::directive (target parallel for simd |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) |
| safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0]) nontemporal(ntm) if (simd: i3) order(concurrent) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (target teams |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) nowait depend(inout: dd[0]) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda)))]] |
| ; |
| [[omp::sequence (directive (target |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| nowait depend(inout: dd[0]) allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda)))]] |
| ; |
| [[omp::sequence (omp::directive (target teams distribute |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) order(concurrent) |
| collapse(1) dist_schedule(static, 16) nowait depend(inout: dd[0]) allocate (omp_default_mem_alloc:f) in_reduction(+:r2) |
| has_device_addr (hda)))]] |
| for (int i = 0; i < 64; i++) |
| ; |
| [[omp::directive (target teams distribute parallel for |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) nowait depend(inout: dd[0]) order(concurrent) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (target teams distribute parallel for simd |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) order(concurrent) |
| safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0]) nontemporal(ntm) if (simd: i3) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (target teams distribute simd |
| device(d) map (tofrom: m) if (i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) order(concurrent) |
| safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0]) nontemporal(ntm) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (target simd |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| safelen(8) simdlen(4) lastprivate (l) linear(ll: 1) aligned(q: 32) reduction(+:r) |
| nowait depend(inout: dd[0]) nontemporal(ntm) if(simd:i3) order(concurrent) |
| allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (taskgroup task_reduction(+:r2) allocate (r2)), |
| omp::directive (taskloop simd |
| 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) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm) |
| order(concurrent) allocate (f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (omp::directive (taskgroup task_reduction(+:r) allocate (r)), |
| directive (taskloop simd |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(i1) final(fi) mergeable nogroup priority (pp) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) in_reduction(+:r) nontemporal(ntm) |
| order(concurrent) allocate (f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (taskwait)]]; |
| [[omp::directive (taskloop simd |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) if(taskloop: i1) final(fi) priority (pp) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(+:r) if (simd: i3) nontemporal(ntm) |
| order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (taskgroup task_reduction(+:r2) allocate (r2)), |
| omp::directive (taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) in_reduction(+:r2) allocate (f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (taskgroup task_reduction(+:r2) allocate (r2)), |
| omp::directive (task |
| private (p) firstprivate (f) shared (s) default(shared) untied if(task: i1) final(fi) mergeable priority (pp) |
| in_reduction(+:r2) allocate (f)))]] |
| ; |
| [[omp::directive (taskyield)]]; |
| [[omp::directive (target data if (target data: i1) device(d) map (tofrom: m) use_device_ptr (q) use_device_addr (p))]] |
| ; |
| [[omp::directive (target enter data if (target enter data: i1) device(d) map (to: m) depend(inout: dd[0]) nowait)]] |
| ; |
| [[omp::directive (target exit data if (target exit data: i1) device(d) map (from: m) depend(inout: dd[0]) nowait)]] |
| ; |
| [[omp::directive (target update if (target update: i1) device(d) to (m) depend(inout: dd[0]) nowait)]] |
| ; |
| [[omp::directive (target update if (target update: i1) device(d) from (m) depend(inout: dd[0]) nowait)]] |
| ; |
| [[omp::directive (taskwait)]]; |
| [[omp::sequence (directive (target nowait depend(inout: dd[0]) in_reduction(+:r2)), |
| directive (teams distribute |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) allocate (omp_default_mem_alloc: f) order(concurrent)))]] |
| for (int i = 0; i < 64; i++) |
| ; |
| [[omp::directive (teams |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| allocate (omp_default_mem_alloc: f))]] |
| ; |
| [[omp::sequence (omp::directive (target), |
| omp::directive (teams distribute parallel for |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) order(concurrent) allocate (omp_default_mem_alloc: f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (target), |
| directive (teams distribute parallel for simd |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) order(concurrent) |
| safelen(8) simdlen(4) aligned(q: 32) if (simd: i3) nontemporal(ntm) |
| allocate (omp_default_mem_alloc: f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (target), |
| directive (teams distribute simd |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) order(concurrent) |
| safelen(8) simdlen(4) aligned(q: 32) if(i3) nontemporal(ntm) |
| allocate (omp_default_mem_alloc: f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (teams distribute parallel for |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) copyin(t) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (teams distribute parallel for |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) order(concurrent) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (teams distribute parallel for simd |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) |
| safelen(8) simdlen(4) aligned(q: 32) if (simd: i3) nontemporal(ntm) copyin(t) |
| allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (teams distribute parallel for simd |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) |
| if (parallel: i2) num_threads (nth) proc_bind(spread) |
| lastprivate (l) schedule(static, 4) order(concurrent) |
| safelen(8) simdlen(4) aligned(q: 32) if (simd: i3) nontemporal(ntm) |
| allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (teams distribute simd |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) |
| collapse(1) dist_schedule(static, 16) order(concurrent) |
| safelen(8) simdlen(4) aligned(q: 32) if(i3) nontemporal(ntm) allocate(f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel master |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) reduction(+:r) |
| num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]] |
| ; |
| [[omp::directive (parallel masked |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) reduction(+:r) |
| num_threads (nth) proc_bind(spread) copyin(t) allocate (f) filter (d))]] |
| ; |
| [[omp::directive (parallel |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) reduction(+:r) |
| num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]] |
| ; |
| [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| omp::directive (master taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) in_reduction(+:r2) allocate (f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| omp::directive (masked taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) in_reduction(+:r2) allocate (f) filter (d)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (master)]]; |
| [[omp::directive (masked)]]; |
| [[omp::directive (masked filter (d))]]; |
| [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| directive (master taskloop simd |
| 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) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm) |
| order(concurrent) allocate (f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| directive (masked taskloop simd |
| 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) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm) |
| order(concurrent) allocate (f) filter (d)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel master taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) if (parallel: i2) num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel masked taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) if (parallel: i2) num_threads (nth) proc_bind(spread) copyin(t) allocate (f) filter (d))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel master taskloop simd |
| 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) |
| 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) |
| order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel masked taskloop simd |
| 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) |
| 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) |
| order(concurrent) allocate (f) filter (d))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| directive (master taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) in_reduction(+:r2)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| directive (masked taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) in_reduction(+:r2) filter (d)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| omp::directive (master taskloop simd |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm) |
| order(concurrent) allocate (f)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)), |
| omp::directive (masked taskloop simd |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm) |
| order(concurrent) allocate (f) filter (d)))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel master taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel masked taskloop |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| reduction(default, +:r) num_threads (nth) proc_bind(spread) copyin(t) allocate (f) filter (d))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel master taskloop simd |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) nontemporal(ntm) num_threads (nth) proc_bind(spread) copyin(t) |
| order(concurrent) allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (parallel masked taskloop simd |
| private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp) |
| safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) nontemporal(ntm) num_threads (nth) proc_bind(spread) copyin(t) |
| order(concurrent) allocate (f) filter (d))]] |
| for (int i = 0; i < 64; i++) |
| ll++; |
| [[omp::directive (loop bind(thread) order(concurrent) |
| private (p) lastprivate (l) collapse(1) reduction(+:r))]] |
| for (l = 0; l < 64; ++l) |
| ll++; |
| [[omp::directive (parallel loop |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) collapse(1) bind(parallel) order(concurrent) allocate (f))]] |
| for (l = 0; l < 64; l++) |
| ll++; |
| [[omp::directive (parallel loop |
| private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread) |
| lastprivate (l) collapse(1) allocate (f))]] |
| for (l = 0; l < 64; l++) |
| ll++; |
| [[omp::directive (teams loop |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) |
| collapse(1) lastprivate (l) bind(teams) allocate (f))]] |
| for (l = 0; l < 64; ++l) |
| ; |
| [[omp::directive (teams loop |
| private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte - 1:nte) thread_limit(tl) |
| collapse(1) lastprivate (l) order(concurrent) allocate (f))]] |
| for (l = 0; l < 64; ++l) |
| ; |
| [[omp::directive (target parallel loop |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| nowait depend(inout: dd[0]) lastprivate (l) bind(parallel) order(concurrent) collapse(1) |
| allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (l = 0; l < 64; ++l) |
| ; |
| [[omp::directive (target parallel loop |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) |
| nowait depend(inout: dd[0]) lastprivate (l) order(concurrent) collapse(1) |
| allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (l = 0; l < 64; ++l) |
| ; |
| [[omp::directive (target teams loop |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) nowait depend(inout: dd[0]) |
| lastprivate (l) bind(teams) collapse(1) |
| allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (l = 0; l < 64; ++l) |
| ; |
| [[omp::directive (target teams loop |
| device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) |
| shared(s) default(shared) reduction(+:r) num_teams(nte - 1 : nte) thread_limit(tl) nowait depend(inout: dd[0]) |
| lastprivate (l) order(concurrent) collapse(1) |
| allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]] |
| for (l = 0; l < 64; ++l) |
| ; |
| [[omp::directive (critical)]] { |
| } |
| [[omp::directive (critical (foobar) hint(omp_sync_hint_none))]] |
| ; |
| [[omp::directive (taskwait depend (inout: dd[0]))]] |
| ; |
| [[omp::directive (taskgroup task_reduction(+:r2) allocate (r2))]] |
| ; |
| [[omp::directive (atomic update seq_cst hint(omp_sync_hint_none))]] |
| p++; |
| [[omp::directive (atomic read hint(omp_sync_hint_none) relaxed)]] |
| f = p; |
| [[omp::directive (atomic write release hint(omp_sync_hint_none))]] |
| p = f; |
| [[omp::directive (flush)]] |
| ; |
| [[omp::directive (flush acq_rel)]] |
| ; |
| [[omp::directive (flush acquire)]] |
| ; |
| [[omp::directive (flush release)]] |
| ; |
| [[omp::directive (flush seq_cst)]] |
| ; |
| [[omp::directive (flush (p, f))]] |
| ; |
| [[omp::directive (simd |
| private (p) lastprivate (l) linear (ll:1) reduction(+:r) collapse(1) safelen(8) simdlen(4) aligned(q: 32) |
| nontemporal(ntm) if(i1))]] |
| for (int i = 0; i < 64; i++) |
| [[omp::directive (ordered simd)]] |
| ll++; |
| [[omp::directive (for |
| private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait |
| ordered allocate (f))]] |
| for (int i = 0; i < 64; i++) |
| [[omp::directive (ordered threads)]] |
| ll++; |
| [[omp::directive(for ordered (1))]] |
| for (l = 0; l < 64; l++) |
| { |
| [[omp::directive(ordered depend (sink: l - 1))]]; |
| [[omp::directive(ordered depend (source))]]; |
| } |
| extern omp_depend_t depobj; |
| [[omp::directive (depobj(depobj) depend(in : dd[0]))]]; |
| [[omp::directive (parallel)]] { |
| if (p) { |
| [[omp::directive (cancel parallel)]]; |
| } else { |
| [[omp::directive (cancellation point parallel)]]; |
| } |
| } |
| [[omp::directive (scope private (p) firstprivate (f) reduction(+:r) nowait |
| allocate (omp_default_mem_alloc: r))]] |
| ; |
| [[omp::directive (scope private (p) firstprivate (f) reduction(task, +:r) |
| allocate (omp_default_mem_alloc: f))]] |
| ; |
| extern int t2; |
| [[omp::directive (threadprivate (t2))]]; |
| extern int t2; |
| [[omp::directive (declare reduction (dr: int: omp_out += omp_in) initializer (omp_priv = 0))]] |
| ; |
| [[omp::directive (parallel)]] |
| if (0) |
| ; |
| [[omp::directive (parallel)]] |
| while (0) |
| ; |
| [[omp::directive (parallel)]] |
| switch (0) { case 1: break; default: break; } |
| [[omp::directive (assume no_openmp no_openmp_routines no_parallelism |
| absent (atomic, barrier, cancel, cancellation point) |
| absent (critical, depobj) |
| absent (distribute, flush, loop, masked, master, nothing, ordered) |
| absent (parallel, scan, scope, section, sections, simd, single, task) |
| absent (taskgroup, taskloop, taskwait, taskyield) |
| absent (target, teams, for, error) holds (n1 < n2))]] |
| if (0) |
| ; |
| [[omp::sequence (omp::directive (assume contains (simd)), |
| omp::directive (for simd))]] |
| for (int i = 0; i < 64; i++) |
| ; |
| } |
| |
| void corge1 (); |
| |
| void |
| corge () |
| { |
| [[omp::directive (declare variant (corge1) match (construct={parallel,for}))]] |
| extern void corge2 (); |
| [[omp::sequence (directive (parallel), directive (for))]] |
| for (int i = 0; i < 5; i++) |
| corge2 (); |
| [[omp::directive (declare simd simdlen(4) linear(l) aligned(p:4) uniform(p) inbranch), |
| omp::directive (declare simd simdlen(8) notinbranch)]] |
| extern int corge3 (int l, int *p); |
| [[omp::directive (declare simd simdlen(4) linear(l) aligned(p:4) uniform(p) inbranch), |
| omp::directive (declare simd simdlen(8) notinbranch)]] |
| extern int corge4 (int l, int *p); |
| [[omp::sequence (directive (declare simd simdlen(4) linear(l) aligned(p:4) uniform(p) inbranch), |
| omp::directive (declare simd simdlen(8) notinbranch))]] |
| extern int corge5 (int l, int *p); |
| [[omp::directive (declare target)]]; |
| extern void corge6 (); |
| [[omp::directive (end declare target)]]; |
| } |
| |
| int |
| garply (int a, int *c, int *d, int *e, int *f) |
| { |
| int i; |
| [[omp::directive (simd reduction (inscan, +: a))]] |
| for (i = 0; i < 64; i++) |
| { |
| d[i] = a; |
| [[omp::directive (scan exclusive (a))]] |
| a += c[i]; |
| } |
| [[omp::directive (simd reduction (inscan, +: a))]] |
| for (i = 0; i < 64; i++) |
| { |
| a += c[i]; |
| [[omp::sequence (omp::sequence (omp::directive (scan inclusive (a))))]] |
| d[i] = a; |
| } |
| return a; |
| } |
