Debian Codegraph @

libgomp/testsuite/libgomp.c++/baseptrs-3.C

raw
1 #include <cstdlib>
2 #include <cstring>
3 #include <cassert>
4
5 struct sa0
6 {
7 int *ptr;
8 };
9
10 struct sb0
11 {
12 int arr[10];
13 };
14
15 struct sc0
16 {
17 sa0 a;
18 sb0 b;
19 sc0 (sa0 &my_a, sb0 &my_b) : a(my_a), b(my_b) {}
20 };
21
22 void
23 foo0 ()
24 {
25 sa0 my_a;
26 sb0 my_b;
27
28 my_a.ptr = (int *) malloc (sizeof (int) * 10);
29 sc0 my_c(my_a, my_b);
30
31 memset (my_c.a.ptr, 0, sizeof (int) * 10);
32
33 #pragma omp target map (my_c.a.ptr, my_c.a.ptr[:10])
34 {
35 for (int i = 0; i < 10; i++)
36 my_c.a.ptr[i] = i;
37 }
38
39 for (int i = 0; i < 10; i++)
40 assert (my_c.a.ptr[i] == i);
41
42 memset (my_c.b.arr, 0, sizeof (int) * 10);
43
44 #pragma omp target map (my_c.b.arr[:10])
45 {
46 for (int i = 0; i < 10; i++)
47 my_c.b.arr[i] = i;
48 }
49
50 for (int i = 0; i < 10; i++)
51 assert (my_c.b.arr[i] == i);
52
53 free (my_a.ptr);
54 }
55
56 struct sa
57 {
58 int *ptr;
59 };
60
61 struct sb
62 {
63 int arr[10];
64 };
65
66 struct sc
67 {
68 sa &a;
69 sb &b;
70 sc (sa &my_a, sb &my_b) : a(my_a), b(my_b) {}
71 };
72
73 void
74 foo ()
75 {
76 sa my_a;
77 sb my_b;
78
79 my_a.ptr = (int *) malloc (sizeof (int) * 10);
80 sc my_c(my_a, my_b);
81
82 memset (my_c.a.ptr, 0, sizeof (int) * 10);
83
84 #pragma omp target map (my_c.a.ptr, my_c.a.ptr[:10])
85 {
86 for (int i = 0; i < 10; i++)
87 my_c.a.ptr[i] = i;
88 }
89
90 for (int i = 0; i < 10; i++)
91 assert (my_c.a.ptr[i] == i);
92
93 memset (my_c.b.arr, 0, sizeof (int) * 10);
94
95 #pragma omp target map (my_c.b.arr[:10])
96 {
97 for (int i = 0; i < 10; i++)
98 my_c.b.arr[i] = i;
99 }
100
101 for (int i = 0; i < 10; i++)
102 assert (my_c.b.arr[i] == i);
103
104 free (my_a.ptr);
105 }
106
107 void
108 bar ()
109 {
110 sa my_a;
111 sb my_b;
112
113 my_a.ptr = (int *) malloc (sizeof (int) * 10);
114 sc my_c(my_a, my_b);
115 sc &my_cref = my_c;
116
117 memset (my_cref.a.ptr, 0, sizeof (int) * 10);
118
119 #pragma omp target map (my_cref.a.ptr, my_cref.a.ptr[:10])
120 {
121 for (int i = 0; i < 10; i++)
122 my_cref.a.ptr[i] = i;
123 }
124
125 for (int i = 0; i < 10; i++)
126 assert (my_cref.a.ptr[i] == i);
127
128 memset (my_cref.b.arr, 0, sizeof (int) * 10);
129
130 #pragma omp target map (my_cref.b.arr[:10])
131 {
132 for (int i = 0; i < 10; i++)
133 my_cref.b.arr[i] = i;
134 }
135
136 for (int i = 0; i < 10; i++)
137 assert (my_cref.b.arr[i] == i);
138
139 free (my_a.ptr);
140 }
141
142 struct scp0
143 {
144 sa *a;
145 sb *b;
146 scp0 (sa *my_a, sb *my_b) : a(my_a), b(my_b) {}
147 };
148
149 void
150 foop0 ()
151 {
152 sa *my_a = new sa;
153 sb *my_b = new sb;
154
155 my_a->ptr = new int[10];
156 scp0 *my_c = new scp0(my_a, my_b);
157
158 memset (my_c->a->ptr, 0, sizeof (int) * 10);
159
160 #pragma omp target map (my_c->a, my_c->a[:1], my_c->a->ptr, my_c->a->ptr[:10])
161 {
162 for (int i = 0; i < 10; i++)
163 my_c->a->ptr[i] = i;
164 }
165
166 for (int i = 0; i < 10; i++)
167 assert (my_c->a->ptr[i] == i);
168
169 memset (my_c->b->arr, 0, sizeof (int) * 10);
170
171 #pragma omp target map (my_c->b, my_c->b[:1], my_c->b->arr[:10])
172 {
173 for (int i = 0; i < 10; i++)
174 my_c->b->arr[i] = i;
175 }
176
177 for (int i = 0; i < 10; i++)
178 assert (my_c->b->arr[i] == i);
179
180 delete[] my_a->ptr;
181 delete my_a;
182 delete my_b;
183 }
184
185 struct scp
186 {
187 sa *&a;
188 sb *&b;
189 scp (sa *&my_a, sb *&my_b) : a(my_a), b(my_b) {}
190 };
191
192 void
193 foop ()
194 {
195 sa *my_a = new sa;
196 sb *my_b = new sb;
197
198 my_a->ptr = new int[10];
199 scp *my_c = new scp(my_a, my_b);
200
201 memset (my_c->a->ptr, 0, sizeof (int) * 10);
202
203 #pragma omp target map (my_c->a, my_c->a[:1], my_c->a->ptr, my_c->a->ptr[:10])
204 {
205 for (int i = 0; i < 10; i++)
206 my_c->a->ptr[i] = i;
207 }
208
209 for (int i = 0; i < 10; i++)
210 assert (my_c->a->ptr[i] == i);
211
212 memset (my_c->b->arr, 0, sizeof (int) * 10);
213
214 #pragma omp target map (my_c->b, my_c->b[:1], my_c->b->arr[:10])
215 {
216 for (int i = 0; i < 10; i++)
217 my_c->b->arr[i] = i;
218 }
219
220 for (int i = 0; i < 10; i++)
221 assert (my_c->b->arr[i] == i);
222
223 delete[] my_a->ptr;
224 delete my_a;
225 delete my_b;
226 }
227
228 void
229 barp ()
230 {
231 sa *my_a = new sa;
232 sb *my_b = new sb;
233
234 my_a->ptr = new int[10];
235 scp *my_c = new scp(my_a, my_b);
236 scp *&my_cref = my_c;
237
238 memset (my_cref->a->ptr, 0, sizeof (int) * 10);
239
240 #pragma omp target map (my_cref->a, my_cref->a[:1], my_cref->a->ptr, \
241 my_cref->a->ptr[:10])
242 {
243 for (int i = 0; i < 10; i++)
244 my_cref->a->ptr[i] = i;
245 }
246
247 for (int i = 0; i < 10; i++)
248 assert (my_cref->a->ptr[i] == i);
249
250 memset (my_cref->b->arr, 0, sizeof (int) * 10);
251
252 #pragma omp target map (my_cref->b, my_cref->b[:1], my_cref->b->arr[:10])
253 {
254 for (int i = 0; i < 10; i++)
255 my_cref->b->arr[i] = i;
256 }
257
258 for (int i = 0; i < 10; i++)
259 assert (my_cref->b->arr[i] == i);
260
261 delete my_a->ptr;
262 delete my_a;
263 delete my_b;
264 }
265
266 int main (int argc, char *argv[])
267 {
268 foo0 ();
269 foo ();
270 bar ();
271 foop0 ();
272 foop ();
273 barp ();
274 return 0;
275 }