|
111
|
1 /*
|
|
|
2 Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
|
|
|
3
|
|
|
4 Redistribution and use in source and binary forms, with or without
|
|
|
5 modification, are permitted provided that the following conditions
|
|
|
6 are met:
|
|
|
7
|
|
|
8 * Redistributions of source code must retain the above copyright
|
|
|
9 notice, this list of conditions and the following disclaimer.
|
|
|
10 * Redistributions in binary form must reproduce the above copyright
|
|
|
11 notice, this list of conditions and the following disclaimer in the
|
|
|
12 documentation and/or other materials provided with the distribution.
|
|
|
13 * Neither the name of Intel Corporation nor the names of its
|
|
|
14 contributors may be used to endorse or promote products derived
|
|
|
15 from this software without specific prior written permission.
|
|
|
16
|
|
|
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
18 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
21 HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
22 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
23 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
27 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
28 */
|
|
|
29
|
|
|
30
|
|
|
31 #include <stdio.h>
|
|
|
32 #include <stdarg.h>
|
|
|
33 #ifndef va_copy
|
|
|
34 #define va_copy(dst, src) ((dst) = (src))
|
|
|
35 #endif
|
|
|
36
|
|
|
37 #include "liboffload_msg.h"
|
|
|
38
|
|
|
39 #include "liboffload_error_codes.h"
|
|
|
40
|
|
|
41 /***********************************************/
|
|
|
42 /* error-handling function, liboffload_error_support */
|
|
|
43 /***********************************************/
|
|
|
44
|
|
|
45 void __liboffload_error_support(error_types input_tag, ...)
|
|
|
46 {
|
|
|
47 va_list args;
|
|
|
48 va_start(args, input_tag);
|
|
|
49
|
|
|
50 switch (input_tag) {
|
|
|
51 case c_device_is_not_available:
|
|
|
52 write_message(stderr, msg_c_device_is_not_available, args);
|
|
|
53 break;
|
|
|
54 case c_invalid_device_number:
|
|
|
55 write_message(stderr, msg_c_invalid_device_number, args);
|
|
|
56 break;
|
|
|
57 case c_send_func_ptr:
|
|
|
58 write_message(stderr, msg_c_send_func_ptr, args);
|
|
|
59 break;
|
|
|
60 case c_receive_func_ptr:
|
|
|
61 write_message(stderr, msg_c_receive_func_ptr, args);
|
|
|
62 break;
|
|
|
63 case c_malloc:
|
|
|
64 write_message(stderr, msg_c_malloc, args);
|
|
|
65 break;
|
|
|
66 case c_unknown_mic_device_type:
|
|
|
67 write_message(stderr, msg_c_unknown_mic_device_type, args);
|
|
|
68 break;
|
|
|
69 case c_offload_malloc:
|
|
|
70 write_message(stderr, msg_c_offload_malloc, args);
|
|
|
71 break;
|
|
|
72 case c_offload1:
|
|
|
73 write_message(stderr, msg_c_offload1, args);
|
|
|
74 break;
|
|
|
75 case c_unknown_var_type:
|
|
|
76 write_message(stderr, msg_c_unknown_var_type, args);
|
|
|
77 break;
|
|
|
78 case c_invalid_env_var_value:
|
|
|
79 write_message(stderr, msg_c_invalid_env_var_value, args);
|
|
|
80 break;
|
|
|
81 case c_invalid_env_var_int_value:
|
|
|
82 write_message(stderr, msg_c_invalid_env_var_int_value, args);
|
|
|
83 break;
|
|
|
84 case c_invalid_env_report_value:
|
|
|
85 write_message(stderr, msg_c_invalid_env_report_value, args);
|
|
|
86 break;
|
|
|
87 case c_offload_signaled1:
|
|
|
88 write_message(stderr, msg_c_offload_signaled1, args);
|
|
|
89 break;
|
|
|
90 case c_offload_signaled2:
|
|
|
91 write_message(stderr, msg_c_offload_signaled2, args);
|
|
|
92 break;
|
|
|
93 case c_myowrapper_checkresult:
|
|
|
94 write_message(stderr, msg_c_myowrapper_checkresult, args);
|
|
|
95 break;
|
|
|
96 case c_myotarget_checkresult:
|
|
|
97 write_message(stderr, msg_c_myotarget_checkresult, args);
|
|
|
98 break;
|
|
|
99 case c_offload_descriptor_offload:
|
|
|
100 write_message(stderr, msg_c_offload_descriptor_offload, args);
|
|
|
101 break;
|
|
|
102 case c_merge_var_descs1:
|
|
|
103 write_message(stderr, msg_c_merge_var_descs1, args);
|
|
|
104 break;
|
|
|
105 case c_merge_var_descs2:
|
|
|
106 write_message(stderr, msg_c_merge_var_descs2, args);
|
|
|
107 break;
|
|
|
108 case c_mic_parse_env_var_list1:
|
|
|
109 write_message(stderr, msg_c_mic_parse_env_var_list1, args);
|
|
|
110 break;
|
|
|
111 case c_mic_parse_env_var_list2:
|
|
|
112 write_message(stderr, msg_c_mic_parse_env_var_list2, args);
|
|
|
113 break;
|
|
|
114 case c_mic_process_exit_ret:
|
|
|
115 write_message(stderr, msg_c_mic_process_exit_ret, args);
|
|
|
116 break;
|
|
|
117 case c_mic_process_exit_sig:
|
|
|
118 write_message(stderr, msg_c_mic_process_exit_sig, args);
|
|
|
119 break;
|
|
|
120 case c_mic_process_exit:
|
|
|
121 write_message(stderr, msg_c_mic_process_exit, args);
|
|
|
122 break;
|
|
|
123 case c_mic_init3:
|
|
|
124 write_message(stderr, msg_c_mic_init3, args);
|
|
|
125 break;
|
|
|
126 case c_mic_init4:
|
|
|
127 write_message(stderr, msg_c_mic_init4, args);
|
|
|
128 break;
|
|
|
129 case c_mic_init5:
|
|
|
130 write_message(stderr, msg_c_mic_init5, args);
|
|
|
131 break;
|
|
|
132 case c_mic_init6:
|
|
|
133 write_message(stderr, msg_c_mic_init6, args);
|
|
|
134 break;
|
|
|
135 case c_mic_init7:
|
|
|
136 write_message(stderr, msg_c_mic_init7, args);
|
|
|
137 break;
|
|
|
138 case c_mic_init8:
|
|
|
139 write_message(stderr, msg_c_mic_init8, args);
|
|
|
140 break;
|
|
|
141 case c_mic_init9:
|
|
|
142 write_message(stderr, msg_c_mic_init9, args);
|
|
|
143 break;
|
|
|
144 case c_mic_init10:
|
|
|
145 write_message(stderr, msg_c_mic_init10, args);
|
|
|
146 break;
|
|
|
147 case c_mic_init11:
|
|
|
148 write_message(stderr, msg_c_mic_init11, args);
|
|
|
149 break;
|
|
|
150 case c_no_static_var_data:
|
|
|
151 write_message(stderr, msg_c_no_static_var_data, args);
|
|
|
152 break;
|
|
|
153 case c_no_ptr_data:
|
|
|
154 write_message(stderr, msg_c_no_ptr_data, args);
|
|
|
155 break;
|
|
|
156 case c_get_engine_handle:
|
|
|
157 write_message(stderr, msg_c_get_engine_handle, args);
|
|
|
158 break;
|
|
|
159 case c_get_engine_index:
|
|
|
160 write_message(stderr, msg_c_get_engine_index, args);
|
|
|
161 break;
|
|
|
162 case c_process_create:
|
|
|
163 write_message(stderr, msg_c_process_create, args);
|
|
|
164 break;
|
|
|
165 case c_process_set_cache_size:
|
|
|
166 write_message(stderr, msg_c_process_set_cache_size, args);
|
|
|
167 break;
|
|
|
168 case c_process_wait_shutdown:
|
|
|
169 write_message(stderr, msg_c_process_wait_shutdown, args);
|
|
|
170 break;
|
|
|
171 case c_process_proxy_flush:
|
|
|
172 write_message(stderr, msg_c_process_proxy_flush, args);
|
|
|
173 break;
|
|
|
174 case c_process_get_func_handles:
|
|
|
175 write_message(stderr, msg_c_process_get_func_handles, args);
|
|
|
176 break;
|
|
|
177 case c_load_library:
|
|
|
178 write_message(stderr, msg_c_load_library, args);
|
|
|
179 break;
|
|
|
180 case c_coipipe_max_number:
|
|
|
181 write_message(stderr, msg_c_coi_pipeline_max_number, args);
|
|
|
182 break;
|
|
|
183 case c_pipeline_create:
|
|
|
184 write_message(stderr, msg_c_pipeline_create, args);
|
|
|
185 break;
|
|
|
186 case c_pipeline_run_func:
|
|
|
187 write_message(stderr, msg_c_pipeline_run_func, args);
|
|
|
188 break;
|
|
|
189 case c_pipeline_start_run_funcs:
|
|
|
190 write_message(stderr, msg_c_pipeline_start_run_funcs, args);
|
|
|
191 break;
|
|
|
192 case c_buf_create:
|
|
|
193 write_message(stderr, msg_c_buf_create, args);
|
|
|
194 break;
|
|
|
195 case c_buf_create_out_of_mem:
|
|
|
196 write_message(stderr, msg_c_buf_create_out_of_mem, args);
|
|
|
197 break;
|
|
|
198 case c_buf_create_from_mem:
|
|
|
199 write_message(stderr, msg_c_buf_create_from_mem, args);
|
|
|
200 break;
|
|
|
201 case c_buf_destroy:
|
|
|
202 write_message(stderr, msg_c_buf_destroy, args);
|
|
|
203 break;
|
|
|
204 case c_buf_map:
|
|
|
205 write_message(stderr, msg_c_buf_map, args);
|
|
|
206 break;
|
|
|
207 case c_buf_unmap:
|
|
|
208 write_message(stderr, msg_c_buf_unmap, args);
|
|
|
209 break;
|
|
|
210 case c_buf_read:
|
|
|
211 write_message(stderr, msg_c_buf_read, args);
|
|
|
212 break;
|
|
|
213 case c_buf_write:
|
|
|
214 write_message(stderr, msg_c_buf_write, args);
|
|
|
215 break;
|
|
|
216 case c_buf_copy:
|
|
|
217 write_message(stderr, msg_c_buf_copy, args);
|
|
|
218 break;
|
|
|
219 case c_buf_get_address:
|
|
|
220 write_message(stderr, msg_c_buf_get_address, args);
|
|
|
221 break;
|
|
|
222 case c_buf_add_ref:
|
|
|
223 write_message(stderr, msg_c_buf_add_ref, args);
|
|
|
224 break;
|
|
|
225 case c_buf_release_ref:
|
|
|
226 write_message(stderr, msg_c_buf_release_ref, args);
|
|
|
227 break;
|
|
|
228 case c_buf_set_state:
|
|
|
229 write_message(stderr, msg_c_buf_set_state, args);
|
|
|
230 break;
|
|
|
231 case c_event_wait:
|
|
|
232 write_message(stderr, msg_c_event_wait, args);
|
|
|
233 break;
|
|
|
234 case c_zero_or_neg_ptr_len:
|
|
|
235 write_message(stderr, msg_c_zero_or_neg_ptr_len, args);
|
|
|
236 break;
|
|
|
237 case c_zero_or_neg_transfer_size:
|
|
|
238 write_message(stderr, msg_c_zero_or_neg_transfer_size, args);
|
|
|
239 break;
|
|
|
240 case c_bad_ptr_mem_alloc:
|
|
|
241 write_message(stderr, msg_c_bad_ptr_mem_alloc, args);
|
|
|
242 break;
|
|
|
243 case c_bad_ptr_mem_range:
|
|
|
244 write_message(stderr, msg_c_bad_ptr_mem_range, args);
|
|
|
245 break;
|
|
|
246 case c_different_src_and_dstn_sizes:
|
|
|
247 write_message(stderr, msg_c_different_src_and_dstn_sizes, args);
|
|
|
248 break;
|
|
|
249 case c_ranges_dont_match:
|
|
|
250 write_message(stderr, msg_c_ranges_dont_match, args);
|
|
|
251 break;
|
|
|
252 case c_destination_is_over:
|
|
|
253 write_message(stderr, msg_c_destination_is_over, args);
|
|
|
254 break;
|
|
|
255 case c_slice_of_noncont_array:
|
|
|
256 write_message(stderr, msg_c_slice_of_noncont_array, args);
|
|
|
257 break;
|
|
|
258 case c_non_contiguous_dope_vector:
|
|
|
259 write_message(stderr, msg_c_non_contiguous_dope_vector, args);
|
|
|
260 break;
|
|
|
261 case c_pointer_array_mismatch:
|
|
|
262 write_message(stderr, msg_c_pointer_array_mismatch, args);
|
|
|
263 break;
|
|
|
264 case c_omp_invalid_device_num_env:
|
|
|
265 write_message(stderr, msg_c_omp_invalid_device_num_env, args);
|
|
|
266 break;
|
|
|
267 case c_omp_invalid_device_num:
|
|
|
268 write_message(stderr, msg_c_omp_invalid_device_num, args);
|
|
|
269 break;
|
|
|
270 case c_unknown_binary_type:
|
|
|
271 write_message(stderr, msg_c_unknown_binary_type, args);
|
|
|
272 break;
|
|
|
273 case c_multiple_target_exes:
|
|
|
274 write_message(stderr, msg_c_multiple_target_exes, args);
|
|
|
275 break;
|
|
|
276 case c_no_target_exe:
|
|
|
277 write_message(stderr, msg_c_no_target_exe, args);
|
|
|
278 break;
|
|
|
279 case c_report_unknown_timer_node:
|
|
|
280 write_message(stderr, msg_c_report_unknown_timer_node, args);
|
|
|
281 break;
|
|
|
282 case c_report_unknown_trace_node:
|
|
|
283 write_message(stderr, msg_c_report_unknown_trace_node, args);
|
|
|
284 break;
|
|
|
285 case c_incorrect_affinity:
|
|
|
286 write_message(stderr, msg_c_incorrect_affinity, args);
|
|
|
287 break;
|
|
|
288 case c_cannot_set_affinity:
|
|
|
289 write_message(stderr, msg_c_cannot_set_affinity, args);
|
|
|
290 break;
|
|
|
291 case c_mixed_versions:
|
|
|
292 write_message(stderr, msg_c_mixed_versions, args);
|
|
|
293 break;
|
|
|
294 case c_in_with_preallocated:
|
|
|
295 write_message(stderr, msg_c_in_with_preallocated, args);
|
|
|
296 break;
|
|
|
297 case c_report_no_host_exe:
|
|
|
298 write_message(stderr, msg_c_report_no_host_exe, args);
|
|
|
299 break;
|
|
|
300 case c_report_no_target_exe:
|
|
|
301 write_message(stderr, msg_c_report_no_target_exe, args);
|
|
|
302 break;
|
|
|
303 case c_report_path_buff_overflow:
|
|
|
304 write_message(stderr, msg_c_report_path_buff_overflow, args);
|
|
|
305 break;
|
|
|
306 case c_create_pipeline_for_stream:
|
|
|
307 write_message(stderr, msg_c_create_pipeline_for_stream, args);
|
|
|
308 break;
|
|
|
309 case c_offload_streams_are_absent:
|
|
|
310 write_message(stderr, msg_c_offload_streams_are_absent, args);
|
|
|
311 break;
|
|
|
312 case c_offload_no_stream:
|
|
|
313 write_message(stderr, msg_c_offload_no_stream, args);
|
|
|
314 break;
|
|
|
315 case c_offload_device_doesnt_match_to_stream:
|
|
|
316 write_message(stderr,
|
|
|
317 msg_c_offload_device_doesnt_match_to_stream, args);
|
|
|
318 break;
|
|
|
319 case c_get_engine_info:
|
|
|
320 write_message(stderr, msg_c_get_engine_info, args);
|
|
|
321 break;
|
|
|
322 case c_clear_cpu_mask:
|
|
|
323 write_message(stderr, msg_c_clear_cpu_mask, args);
|
|
|
324 break;
|
|
|
325 case c_set_cpu_mask:
|
|
|
326 write_message(stderr, msg_c_set_cpu_mask, args);
|
|
|
327 break;
|
|
|
328 case c_unload_library:
|
|
|
329 write_message(stderr, msg_c_unload_library, args);
|
|
|
330 break;
|
|
|
331 case c_target_myo_library:
|
|
|
332 write_message(stderr, msg_c_target_myo_library, args);
|
|
|
333 break;
|
|
|
334 case c_myo_dl_sym:
|
|
|
335 write_message(stderr, msg_c_myo_dl_sym, args);
|
|
|
336 break;
|
|
|
337 case c_bad_myo_free:
|
|
|
338 write_message(stderr, msg_c_bad_myo_free, args);
|
|
|
339 break;
|
|
|
340 }
|
|
|
341 va_end(args);
|
|
|
342 }
|
|
|
343
|
|
|
344 char const * report_get_message_str(error_types input_tag)
|
|
|
345 {
|
|
|
346 switch (input_tag) {
|
|
|
347 case c_report_title:
|
|
|
348 return (offload_get_message_str(msg_c_report_title));
|
|
|
349 case c_report_from_file:
|
|
|
350 return (offload_get_message_str(msg_c_report_from_file));
|
|
|
351 case c_report_offload:
|
|
|
352 return (offload_get_message_str(msg_c_report_offload));
|
|
|
353 case c_report_mic:
|
|
|
354 return (offload_get_message_str(msg_c_report_mic));
|
|
|
355 case c_report_file:
|
|
|
356 return (offload_get_message_str(msg_c_report_file));
|
|
|
357 case c_report_line:
|
|
|
358 return (offload_get_message_str(msg_c_report_line));
|
|
|
359 case c_report_host:
|
|
|
360 return (offload_get_message_str(msg_c_report_host));
|
|
|
361 case c_report_tag:
|
|
|
362 return (offload_get_message_str(msg_c_report_tag));
|
|
|
363 case c_report_cpu_time:
|
|
|
364 return (offload_get_message_str(msg_c_report_cpu_time));
|
|
|
365 case c_report_seconds:
|
|
|
366 return (offload_get_message_str(msg_c_report_seconds));
|
|
|
367 case c_report_cpu_to_mic_data:
|
|
|
368 return (offload_get_message_str(msg_c_report_cpu_to_mic_data));
|
|
|
369 case c_report_bytes:
|
|
|
370 return (offload_get_message_str(msg_c_report_bytes));
|
|
|
371 case c_report_mic_time:
|
|
|
372 return (offload_get_message_str(msg_c_report_mic_time));
|
|
|
373 case c_report_mic_to_cpu_data:
|
|
|
374 return (offload_get_message_str(msg_c_report_mic_to_cpu_data));
|
|
|
375 case c_report_compute:
|
|
|
376 return (offload_get_message_str(msg_c_report_compute));
|
|
|
377 case c_report_copyin_data:
|
|
|
378 return (offload_get_message_str(msg_c_report_copyin_data));
|
|
|
379 case c_report_copyout_data:
|
|
|
380 return (offload_get_message_str(msg_c_report_copyout_data));
|
|
|
381 case c_report_create_buf_host:
|
|
|
382 return (offload_get_message_str(c_report_create_buf_host));
|
|
|
383 case c_report_create_buf_mic:
|
|
|
384 return (offload_get_message_str(msg_c_report_create_buf_mic));
|
|
|
385 case c_report_destroy:
|
|
|
386 return (offload_get_message_str(msg_c_report_destroy));
|
|
|
387 case c_report_gather_copyin_data:
|
|
|
388 return (offload_get_message_str(msg_c_report_gather_copyin_data));
|
|
|
389 case c_report_gather_copyout_data:
|
|
|
390 return (offload_get_message_str(msg_c_report_gather_copyout_data));
|
|
|
391 case c_report_state_signal:
|
|
|
392 return (offload_get_message_str(msg_c_report_state_signal));
|
|
|
393 case c_report_signal:
|
|
|
394 return (offload_get_message_str(msg_c_report_signal));
|
|
|
395 case c_report_wait:
|
|
|
396 return (offload_get_message_str(msg_c_report_wait));
|
|
|
397 case c_report_init:
|
|
|
398 return (offload_get_message_str(msg_c_report_init));
|
|
|
399 case c_report_init_func:
|
|
|
400 return (offload_get_message_str(msg_c_report_init_func));
|
|
|
401 case c_report_logical_card:
|
|
|
402 return (offload_get_message_str(msg_c_report_logical_card));
|
|
|
403 case c_report_mic_myo_fptr:
|
|
|
404 return (offload_get_message_str(msg_c_report_mic_myo_fptr));
|
|
|
405 case c_report_mic_myo_shared:
|
|
|
406 return (offload_get_message_str(msg_c_report_mic_myo_shared));
|
|
|
407 case c_report_myoacquire:
|
|
|
408 return (offload_get_message_str(msg_c_report_myoacquire));
|
|
|
409 case c_report_myofini:
|
|
|
410 return (offload_get_message_str(msg_c_report_myofini));
|
|
|
411 case c_report_myoinit:
|
|
|
412 return (offload_get_message_str(msg_c_report_myoinit));
|
|
|
413 case c_report_myoregister:
|
|
|
414 return (offload_get_message_str(msg_c_report_myoregister));
|
|
|
415 case c_report_myorelease:
|
|
|
416 return (offload_get_message_str(msg_c_report_myorelease));
|
|
|
417 case c_report_myosharedalignedfree:
|
|
|
418 return (
|
|
|
419 offload_get_message_str(msg_c_report_myosharedalignedfree));
|
|
|
420 case c_report_myosharedalignedmalloc:
|
|
|
421 return (
|
|
|
422 offload_get_message_str(msg_c_report_myosharedalignedmalloc));
|
|
|
423 case c_report_myosharedfree:
|
|
|
424 return (offload_get_message_str(msg_c_report_myosharedfree));
|
|
|
425 case c_report_myosharedmalloc:
|
|
|
426 return (offload_get_message_str(msg_c_report_myosharedmalloc));
|
|
|
427 case c_report_physical_card:
|
|
|
428 return (offload_get_message_str(msg_c_report_physical_card));
|
|
|
429 case c_report_receive_pointer_data:
|
|
|
430 return (
|
|
|
431 offload_get_message_str(msg_c_report_receive_pointer_data));
|
|
|
432 case c_report_received_pointer_data:
|
|
|
433 return (
|
|
|
434 offload_get_message_str(msg_c_report_received_pointer_data));
|
|
|
435 case c_report_register:
|
|
|
436 return (offload_get_message_str(msg_c_report_register));
|
|
|
437 case c_report_scatter_copyin_data:
|
|
|
438 return (offload_get_message_str(msg_c_report_scatter_copyin_data));
|
|
|
439 case c_report_scatter_copyout_data:
|
|
|
440 return (
|
|
|
441 offload_get_message_str(msg_c_report_scatter_copyout_data));
|
|
|
442 case c_report_send_pointer_data:
|
|
|
443 return (offload_get_message_str(msg_c_report_send_pointer_data));
|
|
|
444 case c_report_sent_pointer_data:
|
|
|
445 return (offload_get_message_str(msg_c_report_sent_pointer_data));
|
|
|
446 case c_report_start:
|
|
|
447 return (offload_get_message_str(msg_c_report_start));
|
|
|
448 case c_report_start_target_func:
|
|
|
449 return (offload_get_message_str(msg_c_report_start_target_func));
|
|
|
450 case c_report_state:
|
|
|
451 return (offload_get_message_str(msg_c_report_state));
|
|
|
452 case c_report_unregister:
|
|
|
453 return (offload_get_message_str(msg_c_report_unregister));
|
|
|
454 case c_report_var:
|
|
|
455 return (offload_get_message_str(msg_c_report_var));
|
|
|
456 case c_report_stream:
|
|
|
457 return (offload_get_message_str(msg_c_report_stream));
|
|
|
458 case c_report_state_stream:
|
|
|
459 return (offload_get_message_str(msg_c_report_state_stream));
|
|
|
460
|
|
|
461 default:
|
|
|
462 LIBOFFLOAD_ERROR(c_report_unknown_trace_node);
|
|
|
463 abort();
|
|
|
464 }
|
|
|
465 return 0;
|
|
|
466 }
|
|
|
467
|
|
|
468 char const * report_get_host_stage_str(int i)
|
|
|
469 {
|
|
|
470 switch (i) {
|
|
|
471 case c_offload_host_total_offload:
|
|
|
472 return (
|
|
|
473 offload_get_message_str(msg_c_report_host_total_offload_time));
|
|
|
474 case c_offload_host_initialize:
|
|
|
475 return (offload_get_message_str(msg_c_report_host_initialize));
|
|
|
476 case c_offload_host_target_acquire:
|
|
|
477 return (
|
|
|
478 offload_get_message_str(msg_c_report_host_target_acquire));
|
|
|
479 case c_offload_host_wait_deps:
|
|
|
480 return (offload_get_message_str(msg_c_report_host_wait_deps));
|
|
|
481 case c_offload_host_setup_buffers:
|
|
|
482 return (offload_get_message_str(msg_c_report_host_setup_buffers));
|
|
|
483 case c_offload_host_alloc_buffers:
|
|
|
484 return (offload_get_message_str(msg_c_report_host_alloc_buffers));
|
|
|
485 case c_offload_host_setup_misc_data:
|
|
|
486 return (
|
|
|
487 offload_get_message_str(msg_c_report_host_setup_misc_data));
|
|
|
488 case c_offload_host_alloc_data_buffer:
|
|
|
489 return (
|
|
|
490 offload_get_message_str(msg_c_report_host_alloc_data_buffer));
|
|
|
491 case c_offload_host_send_pointers:
|
|
|
492 return (offload_get_message_str(msg_c_report_host_send_pointers));
|
|
|
493 case c_offload_host_gather_inputs:
|
|
|
494 return (offload_get_message_str(msg_c_report_host_gather_inputs));
|
|
|
495 case c_offload_host_map_in_data_buffer:
|
|
|
496 return (
|
|
|
497 offload_get_message_str(msg_c_report_host_map_in_data_buffer));
|
|
|
498 case c_offload_host_unmap_in_data_buffer:
|
|
|
499 return (offload_get_message_str(
|
|
|
500 msg_c_report_host_unmap_in_data_buffer));
|
|
|
501 case c_offload_host_start_compute:
|
|
|
502 return (offload_get_message_str(msg_c_report_host_start_compute));
|
|
|
503 case c_offload_host_wait_compute:
|
|
|
504 return (offload_get_message_str(msg_c_report_host_wait_compute));
|
|
|
505 case c_offload_host_start_buffers_reads:
|
|
|
506 return (offload_get_message_str(
|
|
|
507 msg_c_report_host_start_buffers_reads));
|
|
|
508 case c_offload_host_scatter_outputs:
|
|
|
509 return (
|
|
|
510 offload_get_message_str(msg_c_report_host_scatter_outputs));
|
|
|
511 case c_offload_host_map_out_data_buffer:
|
|
|
512 return (offload_get_message_str(
|
|
|
513 msg_c_report_host_map_out_data_buffer));
|
|
|
514 case c_offload_host_unmap_out_data_buffer:
|
|
|
515 return (offload_get_message_str(
|
|
|
516 msg_c_report_host_unmap_out_data_buffer));
|
|
|
517 case c_offload_host_wait_buffers_reads:
|
|
|
518 return (
|
|
|
519 offload_get_message_str(msg_c_report_host_wait_buffers_reads));
|
|
|
520 case c_offload_host_destroy_buffers:
|
|
|
521 return (
|
|
|
522 offload_get_message_str(msg_c_report_host_destroy_buffers));
|
|
|
523 default:
|
|
|
524 LIBOFFLOAD_ERROR(c_report_unknown_timer_node);
|
|
|
525 abort();
|
|
|
526 }
|
|
|
527 return 0;
|
|
|
528 }
|
|
|
529
|
|
|
530 char const * report_get_target_stage_str(int i)
|
|
|
531 {
|
|
|
532 switch (i) {
|
|
|
533 case c_offload_target_total_time:
|
|
|
534 return (offload_get_message_str(msg_c_report_target_total_time));
|
|
|
535 case c_offload_target_descriptor_setup:
|
|
|
536 return (
|
|
|
537 offload_get_message_str(msg_c_report_target_descriptor_setup));
|
|
|
538 case c_offload_target_func_lookup:
|
|
|
539 return (offload_get_message_str(msg_c_report_target_func_lookup));
|
|
|
540 case c_offload_target_func_time:
|
|
|
541 return (offload_get_message_str(msg_c_report_target_func_time));
|
|
|
542 case c_offload_target_scatter_inputs:
|
|
|
543 return (
|
|
|
544 offload_get_message_str(msg_c_report_target_scatter_inputs));
|
|
|
545 case c_offload_target_add_buffer_refs:
|
|
|
546 return (
|
|
|
547 offload_get_message_str(msg_c_report_target_add_buffer_refs));
|
|
|
548 case c_offload_target_compute:
|
|
|
549 return (offload_get_message_str(msg_c_report_target_compute));
|
|
|
550 case c_offload_target_gather_outputs:
|
|
|
551 return (offload_get_message_str
|
|
|
552 (msg_c_report_target_gather_outputs));
|
|
|
553 case c_offload_target_release_buffer_refs:
|
|
|
554 return (offload_get_message_str(
|
|
|
555 msg_c_report_target_release_buffer_refs));
|
|
|
556 default:
|
|
|
557 LIBOFFLOAD_ERROR(c_report_unknown_timer_node);
|
|
|
558 abort();
|
|
|
559 }
|
|
|
560 return 0;
|
|
|
561 }
|
