Debian Codegraph @

libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-init-1.c

raw
1 /* Test dispatch of events to callbacks. */
2
3 #undef NDEBUG
4 #include <assert.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8 #include <acc_prof.h>
9
10
11 /* Use explicit 'copyin' clauses, to work around "'firstprivate'
12 optimizations", which will cause the value at the point of call to be used
13 (*before* any potential modifications done in callbacks), as opposed to its
14 address being taken, which then later gets dereferenced (*after* any
15 modifications done in callbacks). */
16 #define COPYIN(...) copyin(__VA_ARGS__)
17
18
19 #define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
20
21
22 static acc_prof_reg reg;
23 static acc_prof_reg unreg;
24 static acc_prof_lookup_func lookup;
25 void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
26 {
27 DEBUG_printf ("%s\n", __FUNCTION__);
28
29 reg = reg_;
30 unreg = unreg_;
31 lookup = lookup_;
32 }
33
34
35 static int state = -1;
36
37 #define STATE_OP(state, op) \
38 do \
39 { \
40 typeof (state) state_o = (state); \
41 (void) state_o; \
42 (state)op; \
43 DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
44 } \
45 while (0)
46
47
48 static acc_device_t acc_device_type;
49 static int acc_device_num;
50 static int acc_async = acc_async_sync;
51
52
53 struct tool_info
54 {
55 acc_event_info event_info;
56 struct tool_info *nested;
57 };
58 struct tool_info *tool_info;
59
60 static void cb_device_init_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
61 {
62 DEBUG_printf ("%s\n", __FUNCTION__);
63
64 assert (state == 0
65 || state == 100);
66 STATE_OP (state, ++);
67
68 assert (tool_info == NULL);
69 tool_info = (struct tool_info *) malloc(sizeof *tool_info);
70 assert (tool_info != NULL);
71 tool_info->nested = NULL;
72
73 assert (prof_info->event_type == acc_ev_device_init_start);
74 assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
75 assert (prof_info->version == _ACC_PROF_INFO_VERSION);
76 if (state == 1)
77 assert (prof_info->device_type == acc_device_host);
78 else
79 assert (prof_info->device_type == acc_device_default);
80 assert (prof_info->device_number == acc_device_num);
81 assert (prof_info->thread_id == -1);
82 assert (prof_info->async == acc_async_sync);
83 assert (prof_info->async_queue == prof_info->async);
84 assert (prof_info->src_file == NULL);
85 assert (prof_info->func_name == NULL);
86 assert (prof_info->line_no == -1);
87 assert (prof_info->end_line_no == -1);
88 assert (prof_info->func_line_no == -1);
89 assert (prof_info->func_end_line_no == -1);
90
91 assert (event_info->other_event.event_type == prof_info->event_type);
92 assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
93 assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
94 assert (event_info->other_event.implicit == 0);
95 assert (event_info->other_event.tool_info == NULL);
96
97 assert (api_info->device_api == acc_device_api_none);
98 assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
99 assert (api_info->device_type == prof_info->device_type);
100 assert (api_info->vendor == -1);
101 assert (api_info->device_handle == NULL);
102 assert (api_info->context_handle == NULL);
103 assert (api_info->async_handle == NULL);
104
105 tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
106 event_info->other_event.tool_info = tool_info;
107 }
108
109 static void cb_device_init_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
110 {
111 DEBUG_printf ("%s\n", __FUNCTION__);
112
113 assert (state == 1
114 || state == 101);
115 STATE_OP (state, ++);
116
117 assert (tool_info != NULL);
118 assert (tool_info->event_info.other_event.event_type == acc_ev_device_init_start);
119
120 assert (prof_info->event_type == acc_ev_device_init_end);
121 assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
122 assert (prof_info->version == _ACC_PROF_INFO_VERSION);
123 if (state == 2)
124 assert (prof_info->device_type == acc_device_host);
125 else
126 assert (prof_info->device_type == acc_device_default);
127 assert (prof_info->device_number == acc_device_num);
128 assert (prof_info->thread_id == -1);
129 assert (prof_info->async == acc_async_sync);
130 assert (prof_info->async_queue == prof_info->async);
131 assert (prof_info->src_file == NULL);
132 assert (prof_info->func_name == NULL);
133 assert (prof_info->line_no == -1);
134 assert (prof_info->end_line_no == -1);
135 assert (prof_info->func_line_no == -1);
136 assert (prof_info->func_end_line_no == -1);
137
138 assert (event_info->other_event.event_type == prof_info->event_type);
139 assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
140 assert (event_info->other_event.parent_construct == acc_construct_runtime_api);
141 assert (event_info->other_event.implicit == 0);
142 assert (event_info->other_event.tool_info == tool_info);
143
144 assert (api_info->device_api == acc_device_api_none);
145 assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
146 assert (api_info->device_type == prof_info->device_type);
147 assert (api_info->vendor == -1);
148 assert (api_info->device_handle == NULL);
149 assert (api_info->context_handle == NULL);
150 assert (api_info->async_handle == NULL);
151
152 free (tool_info);
153 tool_info = NULL;
154 }
155
156 static void cb_compute_construct_start (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
157 {
158 DEBUG_printf ("%s\n", __FUNCTION__);
159
160 assert (state == 10
161 || state == 110);
162 STATE_OP (state, ++);
163
164 assert (tool_info == NULL);
165 tool_info = (struct tool_info *) malloc(sizeof *tool_info);
166 assert (tool_info != NULL);
167 tool_info->nested = NULL;
168
169 assert (prof_info->event_type == acc_ev_compute_construct_start);
170 assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
171 assert (prof_info->version == _ACC_PROF_INFO_VERSION);
172 assert (prof_info->device_type == acc_device_type);
173 assert (prof_info->device_number == acc_device_num);
174 assert (prof_info->thread_id == -1);
175 assert (prof_info->async == /* TODO acc_async */ acc_async_sync);
176 assert (prof_info->async_queue == prof_info->async);
177 assert (prof_info->src_file == NULL);
178 assert (prof_info->func_name == NULL);
179 assert (prof_info->line_no == -1);
180 assert (prof_info->end_line_no == -1);
181 assert (prof_info->func_line_no == -1);
182 assert (prof_info->func_end_line_no == -1);
183
184 assert (event_info->other_event.event_type == prof_info->event_type);
185 assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
186 assert (event_info->other_event.parent_construct == acc_construct_parallel);
187 assert (event_info->other_event.implicit == 0);
188 assert (event_info->other_event.tool_info == NULL);
189
190 assert (api_info->device_api == acc_device_api_none);
191 assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
192 assert (api_info->device_type == prof_info->device_type);
193 assert (api_info->vendor == -1);
194 assert (api_info->device_handle == NULL);
195 assert (api_info->context_handle == NULL);
196 assert (api_info->async_handle == NULL);
197
198 tool_info->event_info.other_event.event_type = event_info->other_event.event_type;
199 event_info->other_event.tool_info = tool_info;
200 }
201
202 static void cb_compute_construct_end (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
203 {
204 DEBUG_printf ("%s\n", __FUNCTION__);
205
206 assert (state == 11
207 || state == 111);
208 #if defined COPYIN
209 /* In an 'async' setting, this event may be triggered before actual 'async'
210 data copying has completed. Given that 'state' appears in 'COPYIN', we
211 first have to synchronize (that is, let the 'async' 'COPYIN' read the
212 current 'state' value)... */
213 if (acc_async != acc_async_sync)
214 {
215 /* "We're not yet accounting for the fact that _OpenACC events may occur
216 during event processing_"; temporarily disable to avoid deadlock. */
217 unreg (acc_ev_none, NULL, acc_toggle_per_thread);
218 acc_wait (acc_async);
219 reg (acc_ev_none, NULL, acc_toggle_per_thread);
220 }
221 /* ... before modifying it in the following. */
222 #endif
223 STATE_OP (state, ++);
224
225 assert (tool_info != NULL);
226 assert (tool_info->event_info.other_event.event_type == acc_ev_compute_construct_start);
227 assert (tool_info->nested == NULL);
228
229 assert (prof_info->event_type == acc_ev_compute_construct_end);
230 assert (prof_info->valid_bytes == _ACC_PROF_INFO_VALID_BYTES);
231 assert (prof_info->version == _ACC_PROF_INFO_VERSION);
232 assert (prof_info->device_type == acc_device_type);
233 assert (prof_info->device_number == acc_device_num);
234 assert (prof_info->thread_id == -1);
235 if (acc_device_type == acc_device_host)
236 assert (prof_info->async == acc_async_sync);
237 else
238 assert (prof_info->async == acc_async);
239 assert (prof_info->async_queue == prof_info->async);
240 assert (prof_info->src_file == NULL);
241 assert (prof_info->func_name == NULL);
242 assert (prof_info->line_no == -1);
243 assert (prof_info->end_line_no == -1);
244 assert (prof_info->func_line_no == -1);
245 assert (prof_info->func_end_line_no == -1);
246
247 assert (event_info->other_event.event_type == prof_info->event_type);
248 assert (event_info->other_event.valid_bytes == _ACC_OTHER_EVENT_INFO_VALID_BYTES);
249 assert (event_info->other_event.parent_construct == acc_construct_parallel);
250 assert (event_info->other_event.implicit == 0);
251 assert (event_info->other_event.tool_info == tool_info);
252
253 if (acc_device_type == acc_device_host)
254 assert (api_info->device_api == acc_device_api_none);
255 else if (acc_device_type == acc_device_radeon)
256 assert (api_info->device_api == acc_device_api_other);
257 else
258 assert (api_info->device_api == acc_device_api_cuda);
259 assert (api_info->valid_bytes == _ACC_API_INFO_VALID_BYTES);
260 assert (api_info->device_type == prof_info->device_type);
261 assert (api_info->vendor == -1);
262 assert (api_info->device_handle == NULL);
263 assert (api_info->context_handle == NULL);
264 assert (api_info->async_handle == NULL);
265
266 free (tool_info);
267 tool_info = NULL;
268 }
269
270
271 int main()
272 {
273 acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
274
275 STATE_OP (state, = 0);
276 reg (acc_ev_device_init_start, cb_device_init_start, acc_reg);
277 reg (acc_ev_device_init_end, cb_device_init_end, acc_reg);
278 reg (acc_ev_compute_construct_start, cb_compute_construct_start, acc_reg);
279 reg (acc_ev_compute_construct_end, cb_compute_construct_end, acc_reg);
280 assert (state == 0);
281
282 acc_init (acc_device_host);
283 assert (state == 2);
284
285 STATE_OP (state, = 10);
286
287 acc_device_type = acc_get_device_type ();
288 acc_device_num = acc_get_device_num (acc_device_type);
289
290 {
291 int state_init;
292 acc_async = 12;
293 #pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
294 {
295 state_init = state;
296 }
297 acc_async = acc_async_sync;
298 #pragma acc wait
299 assert (state_init == 11);
300 }
301 assert (state == 12);
302
303 STATE_OP (state, = 90);
304 acc_shutdown (acc_device_host);
305 assert (state == 90);
306
307
308 STATE_OP (state, = 100);
309 acc_init (acc_device_default);
310 assert (state == 102);
311
312 STATE_OP (state, = 110);
313
314 acc_device_type = acc_get_device_type ();
315 acc_device_num = acc_get_device_num (acc_device_type);
316
317 {
318 int state_init;
319 acc_async = 12;
320 #pragma acc parallel async(acc_async) COPYIN(state) copyout(state_init)
321 {
322 state_init = state;
323 }
324 acc_async = acc_async_sync;
325 #pragma acc wait
326 assert (state_init == 111);
327 }
328 assert (state == 112);
329
330 STATE_OP (state, = 190);
331 acc_shutdown (acc_device_default);
332 assert (state == 190);
333
334 return 0;
335 }