| /* |
| Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved. |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| * Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| * Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| * Neither the name of Intel Corporation nor the names of its |
| contributors may be used to endorse or promote products derived |
| from this software without specific prior written permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| #ifndef va_copy |
| #define va_copy(dst, src) ((dst) = (src)) |
| #endif |
| |
| #include "liboffload_msg.h" |
| |
| #include "liboffload_error_codes.h" |
| |
| /***********************************************/ |
| /* error-handling function, liboffload_error_support */ |
| /***********************************************/ |
| |
| void __liboffload_error_support(error_types input_tag, ...) |
| { |
| va_list args; |
| va_start(args, input_tag); |
| |
| switch (input_tag) { |
| case c_device_is_not_available: |
| write_message(stderr, msg_c_device_is_not_available, args); |
| break; |
| case c_invalid_device_number: |
| write_message(stderr, msg_c_invalid_device_number, args); |
| break; |
| case c_send_func_ptr: |
| write_message(stderr, msg_c_send_func_ptr, args); |
| break; |
| case c_receive_func_ptr: |
| write_message(stderr, msg_c_receive_func_ptr, args); |
| break; |
| case c_malloc: |
| write_message(stderr, msg_c_malloc, args); |
| break; |
| case c_unknown_mic_device_type: |
| write_message(stderr, msg_c_unknown_mic_device_type, args); |
| break; |
| case c_offload_malloc: |
| write_message(stderr, msg_c_offload_malloc, args); |
| break; |
| case c_offload1: |
| write_message(stderr, msg_c_offload1, args); |
| break; |
| case c_unknown_var_type: |
| write_message(stderr, msg_c_unknown_var_type, args); |
| break; |
| case c_invalid_env_var_value: |
| write_message(stderr, msg_c_invalid_env_var_value, args); |
| break; |
| case c_invalid_env_var_int_value: |
| write_message(stderr, msg_c_invalid_env_var_int_value, args); |
| break; |
| case c_invalid_env_report_value: |
| write_message(stderr, msg_c_invalid_env_report_value, args); |
| break; |
| case c_offload_signaled1: |
| write_message(stderr, msg_c_offload_signaled1, args); |
| break; |
| case c_offload_signaled2: |
| write_message(stderr, msg_c_offload_signaled2, args); |
| break; |
| case c_myowrapper_checkresult: |
| write_message(stderr, msg_c_myowrapper_checkresult, args); |
| break; |
| case c_myotarget_checkresult: |
| write_message(stderr, msg_c_myotarget_checkresult, args); |
| break; |
| case c_offload_descriptor_offload: |
| write_message(stderr, msg_c_offload_descriptor_offload, args); |
| break; |
| case c_merge_var_descs1: |
| write_message(stderr, msg_c_merge_var_descs1, args); |
| break; |
| case c_merge_var_descs2: |
| write_message(stderr, msg_c_merge_var_descs2, args); |
| break; |
| case c_mic_parse_env_var_list1: |
| write_message(stderr, msg_c_mic_parse_env_var_list1, args); |
| break; |
| case c_mic_parse_env_var_list2: |
| write_message(stderr, msg_c_mic_parse_env_var_list2, args); |
| break; |
| case c_mic_process_exit_ret: |
| write_message(stderr, msg_c_mic_process_exit_ret, args); |
| break; |
| case c_mic_process_exit_sig: |
| write_message(stderr, msg_c_mic_process_exit_sig, args); |
| break; |
| case c_mic_process_exit: |
| write_message(stderr, msg_c_mic_process_exit, args); |
| break; |
| case c_mic_init3: |
| write_message(stderr, msg_c_mic_init3, args); |
| break; |
| case c_mic_init4: |
| write_message(stderr, msg_c_mic_init4, args); |
| break; |
| case c_mic_init5: |
| write_message(stderr, msg_c_mic_init5, args); |
| break; |
| case c_mic_init6: |
| write_message(stderr, msg_c_mic_init6, args); |
| break; |
| case c_mic_init7: |
| write_message(stderr, msg_c_mic_init7, args); |
| break; |
| case c_mic_init8: |
| write_message(stderr, msg_c_mic_init8, args); |
| break; |
| case c_mic_init9: |
| write_message(stderr, msg_c_mic_init9, args); |
| break; |
| case c_mic_init10: |
| write_message(stderr, msg_c_mic_init10, args); |
| break; |
| case c_mic_init11: |
| write_message(stderr, msg_c_mic_init11, args); |
| break; |
| case c_no_static_var_data: |
| write_message(stderr, msg_c_no_static_var_data, args); |
| break; |
| case c_no_ptr_data: |
| write_message(stderr, msg_c_no_ptr_data, args); |
| break; |
| case c_get_engine_handle: |
| write_message(stderr, msg_c_get_engine_handle, args); |
| break; |
| case c_get_engine_index: |
| write_message(stderr, msg_c_get_engine_index, args); |
| break; |
| case c_process_create: |
| write_message(stderr, msg_c_process_create, args); |
| break; |
| case c_process_set_cache_size: |
| write_message(stderr, msg_c_process_set_cache_size, args); |
| break; |
| case c_process_wait_shutdown: |
| write_message(stderr, msg_c_process_wait_shutdown, args); |
| break; |
| case c_process_proxy_flush: |
| write_message(stderr, msg_c_process_proxy_flush, args); |
| break; |
| case c_process_get_func_handles: |
| write_message(stderr, msg_c_process_get_func_handles, args); |
| break; |
| case c_load_library: |
| write_message(stderr, msg_c_load_library, args); |
| break; |
| case c_coipipe_max_number: |
| write_message(stderr, msg_c_coi_pipeline_max_number, args); |
| break; |
| case c_pipeline_create: |
| write_message(stderr, msg_c_pipeline_create, args); |
| break; |
| case c_pipeline_run_func: |
| write_message(stderr, msg_c_pipeline_run_func, args); |
| break; |
| case c_pipeline_start_run_funcs: |
| write_message(stderr, msg_c_pipeline_start_run_funcs, args); |
| break; |
| case c_buf_create: |
| write_message(stderr, msg_c_buf_create, args); |
| break; |
| case c_buf_create_out_of_mem: |
| write_message(stderr, msg_c_buf_create_out_of_mem, args); |
| break; |
| case c_buf_create_from_mem: |
| write_message(stderr, msg_c_buf_create_from_mem, args); |
| break; |
| case c_buf_destroy: |
| write_message(stderr, msg_c_buf_destroy, args); |
| break; |
| case c_buf_map: |
| write_message(stderr, msg_c_buf_map, args); |
| break; |
| case c_buf_unmap: |
| write_message(stderr, msg_c_buf_unmap, args); |
| break; |
| case c_buf_read: |
| write_message(stderr, msg_c_buf_read, args); |
| break; |
| case c_buf_write: |
| write_message(stderr, msg_c_buf_write, args); |
| break; |
| case c_buf_copy: |
| write_message(stderr, msg_c_buf_copy, args); |
| break; |
| case c_buf_get_address: |
| write_message(stderr, msg_c_buf_get_address, args); |
| break; |
| case c_buf_add_ref: |
| write_message(stderr, msg_c_buf_add_ref, args); |
| break; |
| case c_buf_release_ref: |
| write_message(stderr, msg_c_buf_release_ref, args); |
| break; |
| case c_buf_set_state: |
| write_message(stderr, msg_c_buf_set_state, args); |
| break; |
| case c_event_wait: |
| write_message(stderr, msg_c_event_wait, args); |
| break; |
| case c_zero_or_neg_ptr_len: |
| write_message(stderr, msg_c_zero_or_neg_ptr_len, args); |
| break; |
| case c_zero_or_neg_transfer_size: |
| write_message(stderr, msg_c_zero_or_neg_transfer_size, args); |
| break; |
| case c_bad_ptr_mem_alloc: |
| write_message(stderr, msg_c_bad_ptr_mem_alloc, args); |
| break; |
| case c_bad_ptr_mem_range: |
| write_message(stderr, msg_c_bad_ptr_mem_range, args); |
| break; |
| case c_different_src_and_dstn_sizes: |
| write_message(stderr, msg_c_different_src_and_dstn_sizes, args); |
| break; |
| case c_ranges_dont_match: |
| write_message(stderr, msg_c_ranges_dont_match, args); |
| break; |
| case c_destination_is_over: |
| write_message(stderr, msg_c_destination_is_over, args); |
| break; |
| case c_slice_of_noncont_array: |
| write_message(stderr, msg_c_slice_of_noncont_array, args); |
| break; |
| case c_non_contiguous_dope_vector: |
| write_message(stderr, msg_c_non_contiguous_dope_vector, args); |
| break; |
| case c_pointer_array_mismatch: |
| write_message(stderr, msg_c_pointer_array_mismatch, args); |
| break; |
| case c_omp_invalid_device_num_env: |
| write_message(stderr, msg_c_omp_invalid_device_num_env, args); |
| break; |
| case c_omp_invalid_device_num: |
| write_message(stderr, msg_c_omp_invalid_device_num, args); |
| break; |
| case c_unknown_binary_type: |
| write_message(stderr, msg_c_unknown_binary_type, args); |
| break; |
| case c_multiple_target_exes: |
| write_message(stderr, msg_c_multiple_target_exes, args); |
| break; |
| case c_no_target_exe: |
| write_message(stderr, msg_c_no_target_exe, args); |
| break; |
| case c_report_unknown_timer_node: |
| write_message(stderr, msg_c_report_unknown_timer_node, args); |
| break; |
| case c_report_unknown_trace_node: |
| write_message(stderr, msg_c_report_unknown_trace_node, args); |
| break; |
| case c_incorrect_affinity: |
| write_message(stderr, msg_c_incorrect_affinity, args); |
| break; |
| case c_cannot_set_affinity: |
| write_message(stderr, msg_c_cannot_set_affinity, args); |
| break; |
| case c_mixed_versions: |
| write_message(stderr, msg_c_mixed_versions, args); |
| break; |
| case c_in_with_preallocated: |
| write_message(stderr, msg_c_in_with_preallocated, args); |
| break; |
| case c_report_no_host_exe: |
| write_message(stderr, msg_c_report_no_host_exe, args); |
| break; |
| case c_report_no_target_exe: |
| write_message(stderr, msg_c_report_no_target_exe, args); |
| break; |
| case c_report_path_buff_overflow: |
| write_message(stderr, msg_c_report_path_buff_overflow, args); |
| break; |
| case c_create_pipeline_for_stream: |
| write_message(stderr, msg_c_create_pipeline_for_stream, args); |
| break; |
| case c_offload_streams_are_absent: |
| write_message(stderr, msg_c_offload_streams_are_absent, args); |
| break; |
| case c_offload_no_stream: |
| write_message(stderr, msg_c_offload_no_stream, args); |
| break; |
| case c_offload_device_doesnt_match_to_stream: |
| write_message(stderr, |
| msg_c_offload_device_doesnt_match_to_stream, args); |
| break; |
| case c_get_engine_info: |
| write_message(stderr, msg_c_get_engine_info, args); |
| break; |
| case c_clear_cpu_mask: |
| write_message(stderr, msg_c_clear_cpu_mask, args); |
| break; |
| case c_set_cpu_mask: |
| write_message(stderr, msg_c_set_cpu_mask, args); |
| break; |
| case c_unload_library: |
| write_message(stderr, msg_c_unload_library, args); |
| break; |
| case c_target_myo_library: |
| write_message(stderr, msg_c_target_myo_library, args); |
| break; |
| case c_myo_dl_sym: |
| write_message(stderr, msg_c_myo_dl_sym, args); |
| break; |
| case c_bad_myo_free: |
| write_message(stderr, msg_c_bad_myo_free, args); |
| break; |
| } |
| va_end(args); |
| } |
| |
| char const * report_get_message_str(error_types input_tag) |
| { |
| switch (input_tag) { |
| case c_report_title: |
| return (offload_get_message_str(msg_c_report_title)); |
| case c_report_from_file: |
| return (offload_get_message_str(msg_c_report_from_file)); |
| case c_report_offload: |
| return (offload_get_message_str(msg_c_report_offload)); |
| case c_report_mic: |
| return (offload_get_message_str(msg_c_report_mic)); |
| case c_report_file: |
| return (offload_get_message_str(msg_c_report_file)); |
| case c_report_line: |
| return (offload_get_message_str(msg_c_report_line)); |
| case c_report_host: |
| return (offload_get_message_str(msg_c_report_host)); |
| case c_report_tag: |
| return (offload_get_message_str(msg_c_report_tag)); |
| case c_report_cpu_time: |
| return (offload_get_message_str(msg_c_report_cpu_time)); |
| case c_report_seconds: |
| return (offload_get_message_str(msg_c_report_seconds)); |
| case c_report_cpu_to_mic_data: |
| return (offload_get_message_str(msg_c_report_cpu_to_mic_data)); |
| case c_report_bytes: |
| return (offload_get_message_str(msg_c_report_bytes)); |
| case c_report_mic_time: |
| return (offload_get_message_str(msg_c_report_mic_time)); |
| case c_report_mic_to_cpu_data: |
| return (offload_get_message_str(msg_c_report_mic_to_cpu_data)); |
| case c_report_compute: |
| return (offload_get_message_str(msg_c_report_compute)); |
| case c_report_copyin_data: |
| return (offload_get_message_str(msg_c_report_copyin_data)); |
| case c_report_copyout_data: |
| return (offload_get_message_str(msg_c_report_copyout_data)); |
| case c_report_create_buf_host: |
| return (offload_get_message_str(c_report_create_buf_host)); |
| case c_report_create_buf_mic: |
| return (offload_get_message_str(msg_c_report_create_buf_mic)); |
| case c_report_destroy: |
| return (offload_get_message_str(msg_c_report_destroy)); |
| case c_report_gather_copyin_data: |
| return (offload_get_message_str(msg_c_report_gather_copyin_data)); |
| case c_report_gather_copyout_data: |
| return (offload_get_message_str(msg_c_report_gather_copyout_data)); |
| case c_report_state_signal: |
| return (offload_get_message_str(msg_c_report_state_signal)); |
| case c_report_signal: |
| return (offload_get_message_str(msg_c_report_signal)); |
| case c_report_wait: |
| return (offload_get_message_str(msg_c_report_wait)); |
| case c_report_init: |
| return (offload_get_message_str(msg_c_report_init)); |
| case c_report_init_func: |
| return (offload_get_message_str(msg_c_report_init_func)); |
| case c_report_logical_card: |
| return (offload_get_message_str(msg_c_report_logical_card)); |
| case c_report_mic_myo_fptr: |
| return (offload_get_message_str(msg_c_report_mic_myo_fptr)); |
| case c_report_mic_myo_shared: |
| return (offload_get_message_str(msg_c_report_mic_myo_shared)); |
| case c_report_myoacquire: |
| return (offload_get_message_str(msg_c_report_myoacquire)); |
| case c_report_myofini: |
| return (offload_get_message_str(msg_c_report_myofini)); |
| case c_report_myoinit: |
| return (offload_get_message_str(msg_c_report_myoinit)); |
| case c_report_myoregister: |
| return (offload_get_message_str(msg_c_report_myoregister)); |
| case c_report_myorelease: |
| return (offload_get_message_str(msg_c_report_myorelease)); |
| case c_report_myosharedalignedfree: |
| return ( |
| offload_get_message_str(msg_c_report_myosharedalignedfree)); |
| case c_report_myosharedalignedmalloc: |
| return ( |
| offload_get_message_str(msg_c_report_myosharedalignedmalloc)); |
| case c_report_myosharedfree: |
| return (offload_get_message_str(msg_c_report_myosharedfree)); |
| case c_report_myosharedmalloc: |
| return (offload_get_message_str(msg_c_report_myosharedmalloc)); |
| case c_report_physical_card: |
| return (offload_get_message_str(msg_c_report_physical_card)); |
| case c_report_receive_pointer_data: |
| return ( |
| offload_get_message_str(msg_c_report_receive_pointer_data)); |
| case c_report_received_pointer_data: |
| return ( |
| offload_get_message_str(msg_c_report_received_pointer_data)); |
| case c_report_register: |
| return (offload_get_message_str(msg_c_report_register)); |
| case c_report_scatter_copyin_data: |
| return (offload_get_message_str(msg_c_report_scatter_copyin_data)); |
| case c_report_scatter_copyout_data: |
| return ( |
| offload_get_message_str(msg_c_report_scatter_copyout_data)); |
| case c_report_send_pointer_data: |
| return (offload_get_message_str(msg_c_report_send_pointer_data)); |
| case c_report_sent_pointer_data: |
| return (offload_get_message_str(msg_c_report_sent_pointer_data)); |
| case c_report_start: |
| return (offload_get_message_str(msg_c_report_start)); |
| case c_report_start_target_func: |
| return (offload_get_message_str(msg_c_report_start_target_func)); |
| case c_report_state: |
| return (offload_get_message_str(msg_c_report_state)); |
| case c_report_unregister: |
| return (offload_get_message_str(msg_c_report_unregister)); |
| case c_report_var: |
| return (offload_get_message_str(msg_c_report_var)); |
| case c_report_stream: |
| return (offload_get_message_str(msg_c_report_stream)); |
| case c_report_state_stream: |
| return (offload_get_message_str(msg_c_report_state_stream)); |
| |
| default: |
| LIBOFFLOAD_ERROR(c_report_unknown_trace_node); |
| abort(); |
| } |
| return 0; |
| } |
| |
| char const * report_get_host_stage_str(int i) |
| { |
| switch (i) { |
| case c_offload_host_total_offload: |
| return ( |
| offload_get_message_str(msg_c_report_host_total_offload_time)); |
| case c_offload_host_initialize: |
| return (offload_get_message_str(msg_c_report_host_initialize)); |
| case c_offload_host_target_acquire: |
| return ( |
| offload_get_message_str(msg_c_report_host_target_acquire)); |
| case c_offload_host_wait_deps: |
| return (offload_get_message_str(msg_c_report_host_wait_deps)); |
| case c_offload_host_setup_buffers: |
| return (offload_get_message_str(msg_c_report_host_setup_buffers)); |
| case c_offload_host_alloc_buffers: |
| return (offload_get_message_str(msg_c_report_host_alloc_buffers)); |
| case c_offload_host_setup_misc_data: |
| return ( |
| offload_get_message_str(msg_c_report_host_setup_misc_data)); |
| case c_offload_host_alloc_data_buffer: |
| return ( |
| offload_get_message_str(msg_c_report_host_alloc_data_buffer)); |
| case c_offload_host_send_pointers: |
| return (offload_get_message_str(msg_c_report_host_send_pointers)); |
| case c_offload_host_gather_inputs: |
| return (offload_get_message_str(msg_c_report_host_gather_inputs)); |
| case c_offload_host_map_in_data_buffer: |
| return ( |
| offload_get_message_str(msg_c_report_host_map_in_data_buffer)); |
| case c_offload_host_unmap_in_data_buffer: |
| return (offload_get_message_str( |
| msg_c_report_host_unmap_in_data_buffer)); |
| case c_offload_host_start_compute: |
| return (offload_get_message_str(msg_c_report_host_start_compute)); |
| case c_offload_host_wait_compute: |
| return (offload_get_message_str(msg_c_report_host_wait_compute)); |
| case c_offload_host_start_buffers_reads: |
| return (offload_get_message_str( |
| msg_c_report_host_start_buffers_reads)); |
| case c_offload_host_scatter_outputs: |
| return ( |
| offload_get_message_str(msg_c_report_host_scatter_outputs)); |
| case c_offload_host_map_out_data_buffer: |
| return (offload_get_message_str( |
| msg_c_report_host_map_out_data_buffer)); |
| case c_offload_host_unmap_out_data_buffer: |
| return (offload_get_message_str( |
| msg_c_report_host_unmap_out_data_buffer)); |
| case c_offload_host_wait_buffers_reads: |
| return ( |
| offload_get_message_str(msg_c_report_host_wait_buffers_reads)); |
| case c_offload_host_destroy_buffers: |
| return ( |
| offload_get_message_str(msg_c_report_host_destroy_buffers)); |
| default: |
| LIBOFFLOAD_ERROR(c_report_unknown_timer_node); |
| abort(); |
| } |
| return 0; |
| } |
| |
| char const * report_get_target_stage_str(int i) |
| { |
| switch (i) { |
| case c_offload_target_total_time: |
| return (offload_get_message_str(msg_c_report_target_total_time)); |
| case c_offload_target_descriptor_setup: |
| return ( |
| offload_get_message_str(msg_c_report_target_descriptor_setup)); |
| case c_offload_target_func_lookup: |
| return (offload_get_message_str(msg_c_report_target_func_lookup)); |
| case c_offload_target_func_time: |
| return (offload_get_message_str(msg_c_report_target_func_time)); |
| case c_offload_target_scatter_inputs: |
| return ( |
| offload_get_message_str(msg_c_report_target_scatter_inputs)); |
| case c_offload_target_add_buffer_refs: |
| return ( |
| offload_get_message_str(msg_c_report_target_add_buffer_refs)); |
| case c_offload_target_compute: |
| return (offload_get_message_str(msg_c_report_target_compute)); |
| case c_offload_target_gather_outputs: |
| return (offload_get_message_str |
| (msg_c_report_target_gather_outputs)); |
| case c_offload_target_release_buffer_refs: |
| return (offload_get_message_str( |
| msg_c_report_target_release_buffer_refs)); |
| default: |
| LIBOFFLOAD_ERROR(c_report_unknown_timer_node); |
| abort(); |
| } |
| return 0; |
| } |
