Debian Codegraph @

libgomp/testsuite/libgomp.c-target/aarch64/shared.c

raw
1 /* { dg-do run { target aarch64_sve256_hw } } */
2 /* { dg-options "-msve-vector-bits=256 -fopenmp -O2" } */
3
4 #pragma GCC target "+sve"
5
6 #include <arm_sve.h>
7 #include <stdlib.h>
8 #include <omp.h>
9
10 static void __attribute__ ((noipa))
11 compare_vec (svint32_t x, svint32_t y)
12 {
13 svbool_t p = svnot_b_z (svptrue_b32 (), svcmpeq_s32 (svptrue_b32 (), x, y));
14
15 if (svptest_any (svptrue_b32 (), p))
16 __builtin_abort ();
17 }
18
19 static void __attribute__ ((noipa))
20 compare_vecb (svbool_t x, svbool_t y)
21 {
22 svbool_t p = sveor_b_z (svptrue_b32 (), x, y);
23
24 if (svptest_any (svptrue_b32 (), p))
25 __builtin_abort ();
26 }
27
28 void __attribute__ ((noipa))
29 implicit_shared_default (svint32_t a, svint32_t b, svbool_t p)
30 {
31
32 #pragma omp parallel default (shared) num_threads (10)
33 {
34 /* 'a', 'b' and 'p' are implicitly shared. */
35 compare_vec (a, svindex_s32 (0, 1));
36 compare_vec (b, svindex_s32 (8, 1));
37 compare_vecb (p, svptrue_b32 ());
38
39 #pragma omp barrier
40 if (omp_get_thread_num () == 2)
41 a = svadd_s32_z (p, a, b);
42
43 #pragma omp barrier
44 if (omp_get_thread_num () == 0)
45 {
46 compare_vec (a, svindex_s32 (8, 2));
47 compare_vec (b, svindex_s32 (8, 1));
48 compare_vecb (p, svptrue_b32 ());
49 b = svadd_s32_z (p, a, b);
50 }
51
52 #pragma omp barrier
53 compare_vec (a, svindex_s32 (8, 2));
54 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
55
56 #pragma omp barrier
57 if (omp_get_thread_num () == 0 || omp_get_thread_num () == 2)
58 {
59 compare_vec (a, svindex_s32 (8, 2));
60 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
61 }
62 }
63 }
64
65 void __attribute__ ((noipa))
66 explicit_shared (svint32_t a, svint32_t b, svbool_t p)
67 {
68
69 #pragma omp parallel shared (a, b, p) num_threads (12)
70 {
71 /* 'a', 'b' and 'p' are explicitly shared. */
72 compare_vec (a, svindex_s32 (0, 1));
73 compare_vec (b, svindex_s32 (8, 1));
74 compare_vecb (p, svptrue_b32 ());
75
76 #pragma omp barrier
77 if (omp_get_thread_num () == 2)
78 a = svadd_s32_z (p, a, b);
79
80 #pragma omp barrier
81 if (omp_get_thread_num () == 0)
82 {
83 compare_vec (a, svindex_s32 (8, 2));
84 compare_vec (b, svindex_s32 (8, 1));
85 compare_vecb (p, svptrue_b32 ());
86 b = svadd_s32_z (p, a, b);
87 }
88
89 #pragma omp barrier
90 compare_vec (a, svindex_s32 (8, 2));
91 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
92
93 #pragma omp barrier
94 if (omp_get_thread_num () == 0 || omp_get_thread_num () == 2)
95 {
96 compare_vec (a, svindex_s32 (8, 2));
97 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
98 }
99 }
100 }
101
102 void __attribute__ ((noipa))
103 implicit_shared_no_default (svint32_t a, svint32_t b, svbool_t p)
104 {
105
106 #pragma omp parallel num_threads (16)
107 {
108 /* 'a', 'b' and 'p' are implicitly shared without default clause. */
109 compare_vec (a, svindex_s32 (0, 1));
110 compare_vec (b, svindex_s32 (8, 1));
111 compare_vecb (p, svptrue_b32 ());
112
113 #pragma omp barrier
114 if (omp_get_thread_num () == 12)
115 a = svadd_s32_z (p, a, b);
116
117 #pragma omp barrier
118 if (omp_get_thread_num () == 15)
119 {
120 compare_vec (a, svindex_s32 (8, 2));
121 compare_vec (b, svindex_s32 (8, 1));
122 compare_vecb (p, svptrue_b32 ());
123 b = svadd_s32_z (p, a, b);
124 }
125
126 #pragma omp barrier
127 compare_vec (a, svindex_s32 (8, 2));
128 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
129
130 #pragma omp barrier
131 if (omp_get_thread_num () == 12 || omp_get_thread_num () == 15)
132 {
133 compare_vec (a, svindex_s32 (8, 2));
134 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
135 }
136 }
137
138 }
139
140 void __attribute__ ((noipa))
141 mix_shared (svint32_t b, svbool_t p)
142 {
143
144 svint32_t a = svindex_s32 (0, 0);
145 int *m = (int *) malloc (8 * sizeof (int));
146 int i;
147
148 #pragma omp parallel for
149 for (i = 0; i < 8; i++)
150 m[i] = i;
151
152 #pragma omp parallel num_threads (16)
153 {
154 compare_vec (a, svindex_s32 (0, 0));
155 compare_vec (b, svindex_s32 (8, 1));
156
157 #pragma omp barrier
158 /* 'm' is predetermined shared here. 'a' is implicitly shared here. */
159 if (omp_get_thread_num () == 10)
160 a = svld1_s32 (svptrue_b32 (), m);
161
162 #pragma omp barrier
163 /* 'a', 'b' and 'p' are implicitly shared without default clause. */
164 compare_vec (a, svindex_s32 (0, 1));
165 compare_vec (b, svindex_s32 (8, 1));
166 compare_vecb (p, svptrue_b32 ());
167
168 #pragma omp barrier
169 if (omp_get_thread_num () == 12)
170 a = svadd_s32_z (p, a, b);
171
172 #pragma omp barrier
173 if (omp_get_thread_num () == 15)
174 {
175 compare_vec (a, svindex_s32 (8, 2));
176 compare_vec (b, svindex_s32 (8, 1));
177 compare_vecb (p, svptrue_b32 ());
178 b = svadd_s32_z (p, a, b);
179 }
180
181 #pragma omp barrier
182 if (omp_get_thread_num () == 12 || omp_get_thread_num () == 15)
183 {
184 compare_vec (a, svindex_s32 (8, 2));
185 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
186 }
187
188 #pragma omp barrier
189 compare_vec (a, svindex_s32 (8, 2));
190 compare_vec (b, svadd_s32_z (p, svindex_s32 (8, 2), svindex_s32 (8, 1)));
191 }
192 }
193
194 #define N __ARM_FEATURE_SVE_BITS
195 #define FIXED_ATTR __attribute__((arm_sve_vector_bits (N)))
196
197 typedef svint32_t v8si FIXED_ATTR;
198
199 void __attribute__ ((noipa))
200 predetermined_shared_static (int n)
201 {
202
203 int *m = (int *) malloc (8 * sizeof (int));
204 int i;
205
206 #pragma omp parallel for
207 /* 'm' is predetermined shared here. */
208 for (i = 0; i < 8; i++)
209 m[i] = i;
210
211 static v8si a = { 0, 1, 2, 3, 4, 5, 6, 7 };
212
213 #pragma omp parallel num_threads (16)
214 {
215 /* 'a' is implicit shared here. */
216 if (n == 0)
217 compare_vec (a, svindex_s32 (0, 1));
218
219 if (n == 1)
220 compare_vec (a, svindex_s32 (1, 1));
221
222 #pragma omp barrier
223 if (omp_get_thread_num () == 12)
224 {
225 if (n == 0)
226 compare_vec (a, svindex_s32 (0, 1));
227
228 if (n == 1)
229 compare_vec (a, svindex_s32 (1, 1));
230
231 a = svadd_s32_z (svptrue_b32 (), a, svindex_s32 (1, 0));
232 }
233
234 #pragma omp barrier
235 if (n == 0)
236 compare_vec (a, svindex_s32 (1, 1));
237
238 if (n == 1)
239 compare_vec (a, svindex_s32 (2, 1));
240 }
241 }
242
243
244 int
245 main ()
246 {
247 svint32_t x = svindex_s32 (0, 1);
248 svint32_t y = svindex_s32 (8, 1);
249 svbool_t p = svptrue_b32 ();
250
251 /* Implicit shared. */
252 implicit_shared_default (x, y, p);
253
254 /* Explicit shared. */
255 explicit_shared (x, y, p);
256
257 /* Implicit shared with no default clause. */
258 implicit_shared_no_default (x, y, p);
259
260 /* Mix shared. */
261 mix_shared (y, p);
262
263 /* Predetermined and static shared. */
264 predetermined_shared_static (0);
265 predetermined_shared_static (1);
266 }