From 5f520819620642ecd2b070f96efa3007ac1f15a1 Mon Sep 17 00:00:00 2001 From: Kirill Yukhin Date: Thu, 13 Nov 2014 14:03:17 +0000 Subject: [PATCH 2/4] OpenMP 4.0 offloading to Intel MIC: liboffloadmic. * Makefile.def: Add liboffloadmic to target_modules. Make liboffloadmic depend on libgomp's configure, libstdc++ and libgcc. * Makefile.in: Regenerate. * configure: Regenerate. * configure.ac: Add liboffloadmic to target binaries. Restrict liboffloadmic for POSIX and i*86, and x86_64 architectures. Add liboffloadmic to noconfig list when C++ is not supported. config/ * target-posix: New file. libcilkrts/ * configure.tgt: Use config/target-posix. liboffloadmic/ Initial commit. Imported from upstream: https://www.openmprtl.org/sites/default/files/liboffload_oss.tgz * Makefile.am: New file. * Makefile.in: New file, generated by automake. * aclocal.m4: New file, generated by aclocal. * configure: New file, generated by autoconf. * configure.ac: New file. * configure.tgt: Ditto. * doc/doxygen/config: Ditto. * doc/doxygen/header.tex: Ditto. * include/coi/common/COIEngine_common.h: Ditto. * include/coi/common/COIMacros_common.h: Ditto. * include/coi/common/COIPerf_common.h : Ditto. * include/coi/common/COIResult_common.h : Ditto. * include/coi/common/COITypes_common.h: Ditto. * include/coi/sink/COIBuffer_sink.h: Ditto. * include/coi/sink/COIPipeline_sink.h: Ditto. * include/coi/sink/COIProcess_sink.h: Ditto. * include/coi/source/COIBuffer_source.h: Ditto. * include/coi/source/COIEngine_source.h: Ditto. * include/coi/source/COIEvent_source.h: Ditto. * include/coi/source/COIPipeline_source.h: Ditto. * include/coi/source/COIProcess_source.h: Ditto. * include/myo/myo.h: Ditto. * include/myo/myoimpl.h: Ditto. * include/myo/myotypes.h: Ditto. * liboffloadmic_host.spec.in: Ditto. * liboffloadmic_target.spec.in: Ditto. * runtime/cean_util.cpp: Ditto. * runtime/cean_util.h: Ditto. * runtime/coi/coi_client.cpp: Ditto. * runtime/coi/coi_client.h: Ditto. * runtime/coi/coi_server.cpp: Ditto. * runtime/coi/coi_server.h: Ditto. * runtime/compiler_if_host.cpp: Ditto. * runtime/compiler_if_host.h: Ditto. * runtime/compiler_if_target.cpp: Ditto. * runtime/compiler_if_target.h: Ditto. * runtime/dv_util.cpp: Ditto. * runtime/dv_util.h: Ditto. * runtime/emulator/coi_common.h: Ditto. * runtime/emulator/coi_device.cpp: Ditto. * runtime/emulator/coi_device.h: Ditto. * runtime/emulator/coi_host.cpp: Ditto. * runtime/emulator/coi_host.h: Ditto. * runtime/emulator/coi_version_asm.h: Ditto. * runtime/emulator/coi_version_linker_script.map: Ditto. * runtime/emulator/myo_client.cpp: Ditto. * runtime/emulator/myo_service.cpp: Ditto. * runtime/emulator/myo_service.h: Ditto. * runtime/emulator/myo_version_asm.h: Ditto. * runtime/emulator/myo_version_linker_script.map: Ditto. * runtime/liboffload_error.c: Ditto. * runtime/liboffload_error_codes.h: Ditto. * runtime/liboffload_msg.c: Ditto. * runtime/liboffload_msg.h: Ditto. * runtime/mic_lib.f90: Ditto. * runtime/offload.h: Ditto. * runtime/offload_common.cpp: Ditto. * runtime/offload_common.h: Ditto. * runtime/offload_engine.cpp: Ditto. * runtime/offload_engine.h: Ditto. * runtime/offload_env.cpp: Ditto. * runtime/offload_env.h: Ditto. * runtime/offload_host.cpp: Ditto. * runtime/offload_host.h: Ditto. * runtime/offload_myo_host.cpp: Ditto. * runtime/offload_myo_host.h: Ditto. * runtime/offload_myo_target.cpp: Ditto. * runtime/offload_myo_target.h: Ditto. * runtime/offload_omp_host.cpp: Ditto. * runtime/offload_omp_target.cpp: Ditto. * runtime/offload_orsl.cpp: Ditto. * runtime/offload_orsl.h: Ditto. * runtime/offload_table.cpp: Ditto. * runtime/offload_table.h: Ditto. * runtime/offload_target.cpp: Ditto. * runtime/offload_target.h: Ditto. * runtime/offload_target_main.cpp: Ditto. * runtime/offload_timer.h: Ditto. * runtime/offload_timer_host.cpp: Ditto. * runtime/offload_timer_target.cpp: Ditto. * runtime/offload_trace.cpp: Ditto. * runtime/offload_trace.h: Ditto. * runtime/offload_util.cpp: Ditto. * runtime/offload_util.h: Ditto. * runtime/ofldbegin.cpp: Ditto. * runtime/ofldend.cpp: Ditto. * runtime/orsl-lite/include/orsl-lite.h: Ditto. * runtime/orsl-lite/lib/orsl-lite.c: Ditto. * runtime/orsl-lite/version.txt: Ditto. * runtime/use_mpss2.txt: Ditto. From-SVN: r217498 --- liboffloadmic/runtime/offload_timer_host.cpp | 379 +++++++++++++++++++++++++++ 1 file changed, 379 insertions(+) create mode 100644 liboffloadmic/runtime/offload_timer_host.cpp (limited to 'liboffloadmic/runtime/offload_timer_host.cpp') diff --git a/liboffloadmic/runtime/offload_timer_host.cpp b/liboffloadmic/runtime/offload_timer_host.cpp new file mode 100644 index 0000000..719af88 --- /dev/null +++ b/liboffloadmic/runtime/offload_timer_host.cpp @@ -0,0 +1,379 @@ +/* + Copyright (c) 2014 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 "offload_timer.h" + +#ifdef __INTEL_COMPILER +#include +#else // __INTEL_COMPILER +#include +#endif // __INTEL_COMPILER + +#include "offload_host.h" +#include +#include +#include + +int timer_enabled = 0; + +#ifdef TIMING_SUPPORT + +int offload_report_level = 0; +int offload_report_enabled = 1; + +static const int host_timer_prefix_spaces[] = { + /*c_offload_host_setup_buffers*/ 0, + /*c_offload_host_initialize*/ 2, + /*c_offload_host_target_acquire*/ 2, + /*c_offload_host_wait_deps*/ 2, + /*c_offload_host_setup_buffers*/ 2, + /*c_offload_host_alloc_buffers*/ 4, + /*c_offload_host_setup_misc_data*/ 2, + /*c_offload_host_alloc_data_buffer*/ 4, + /*c_offload_host_send_pointers*/ 2, + /*c_offload_host_gather_inputs*/ 2, + /*c_offload_host_map_in_data_buffer*/ 4, + /*c_offload_host_unmap_in_data_buffer*/ 4, + /*c_offload_host_start_compute*/ 2, + /*c_offload_host_wait_compute*/ 2, + /*c_offload_host_start_buffers_reads*/ 2, + /*c_offload_host_scatter_outputs*/ 2, + /*c_offload_host_map_out_data_buffer*/ 4, + /*c_offload_host_unmap_out_data_buffer*/ 4, + /*c_offload_host_wait_buffers_reads*/ 2, + /*c_offload_host_destroy_buffers*/ 2 +}; + +const static int target_timer_prefix_spaces[] = { +/*c_offload_target_total_time*/ 0, +/*c_offload_target_descriptor_setup*/ 2, +/*c_offload_target_func_lookup*/ 2, +/*c_offload_target_func_time*/ 2, +/*c_offload_target_scatter_inputs*/ 4, +/*c_offload_target_add_buffer_refs*/ 6, +/*c_offload_target_compute*/ 4, +/*c_offload_target_gather_outputs*/ 4, +/*c_offload_target_release_buffer_refs*/ 6 +}; + +static OffloadHostTimerData* timer_data_head; +static OffloadHostTimerData* timer_data_tail; +static mutex_t timer_data_mutex; + +static void offload_host_phase_name(std::stringstream &ss, int p_node); +static void offload_target_phase_name(std::stringstream &ss, int p_node); + +extern void Offload_Timer_Print(void) +{ + std::string buf; + std::stringstream ss; + const char *stars = + "**************************************************************"; + + ss << "\n\n" << stars << "\n"; + ss << " "; + ss << report_get_message_str(c_report_title) << "\n"; + ss << stars << "\n"; + double frequency = cpu_frequency; + + for (OffloadHostTimerData *pnode = timer_data_head; + pnode != 0; pnode = pnode->next) { + ss << " "; + ss << report_get_message_str(c_report_from_file) << " "<< pnode->file; + ss << report_get_message_str(c_report_line) << " " << pnode->line; + ss << "\n"; + for (int i = 0; i < c_offload_host_max_phase ; i++) { + ss << " "; + offload_host_phase_name(ss, i); + ss << " " << std::fixed << std::setprecision(5); + ss << (double)pnode->phases[i].total / frequency << "\n"; + } + + for (int i = 0; i < c_offload_target_max_phase ; i++) { + double time = 0; + if (pnode->target.frequency != 0) { + time = (double) pnode->target.phases[i].total / + (double) pnode->target.frequency; + } + ss << " "; + offload_target_phase_name(ss, i); + ss << " " << std::fixed << std::setprecision(5); + ss << time << "\n"; + } + } + + buf = ss.str(); + fprintf(stdout, buf.data()); + fflush(stdout); +} + +extern void Offload_Report_Prolog(OffloadHostTimerData *pnode) +{ + double frequency = cpu_frequency; + std::string buf; + std::stringstream ss; + + if (pnode) { + // [Offload] [Mic 0] [File] file.c + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_mic) << " "; + ss << pnode->card_number << "] ["; + ss << report_get_message_str(c_report_file); + ss << "] " << pnode->file << "\n"; + + // [Offload] [Mic 0] [Line] 1234 + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_mic) << " "; + ss << pnode->card_number << "] ["; + ss << report_get_message_str(c_report_line); + ss << "] " << pnode->line << "\n"; + + // [Offload] [Mic 0] [Tag] Tag 1 + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_mic) << " "; + ss << pnode->card_number << "] ["; + ss << report_get_message_str(c_report_tag); + ss << "] " << report_get_message_str(c_report_tag); + ss << " " << pnode->offload_number << "\n"; + + buf = ss.str(); + fprintf(stdout, buf.data()); + fflush(stdout); + } +} + +extern void Offload_Report_Epilog(OffloadHostTimerData * timer_data) +{ + double frequency = cpu_frequency; + std::string buf; + std::stringstream ss; + + OffloadHostTimerData *pnode = timer_data; + + if (!pnode) { + return; + } + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_host) << "] ["; + ss << report_get_message_str(c_report_tag) << " "; + ss << pnode->offload_number << "] ["; + ss << report_get_message_str(c_report_cpu_time) << "] "; + ss << std::fixed << std::setprecision(6); + ss << (double) pnode->phases[0].total / frequency; + ss << report_get_message_str(c_report_seconds) << "\n"; + + if (offload_report_level >= OFFLOAD_REPORT_2) { + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_mic); + ss << " " << pnode->card_number; + ss << "] [" << report_get_message_str(c_report_tag) << " "; + ss << pnode->offload_number << "] ["; + ss << report_get_message_str(c_report_cpu_to_mic_data) << "] "; + ss << pnode->sent_bytes << " "; + ss << report_get_message_str(c_report_bytes) << "\n"; + } + + double time = 0; + if (pnode->target.frequency != 0) { + time = (double) pnode->target.phases[0].total / + (double) pnode->target.frequency; + } + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_mic) << " "; + ss << pnode->card_number<< "] ["; + ss << report_get_message_str(c_report_tag) << " "; + ss << pnode->offload_number << "] ["; + ss << report_get_message_str(c_report_mic_time) << "] "; + ss << std::fixed << std::setprecision(6) << time; + ss << report_get_message_str(c_report_seconds) << "\n"; + + if (offload_report_level >= OFFLOAD_REPORT_2) { + ss << "[" << report_get_message_str(c_report_offload) << "] ["; + ss << report_get_message_str(c_report_mic); + ss << " " << pnode->card_number; + ss << "] [" << report_get_message_str(c_report_tag) << " "; + ss << pnode->offload_number << "] ["; + ss << report_get_message_str(c_report_mic_to_cpu_data) << "] "; + ss << pnode->received_bytes << " "; + ss << report_get_message_str(c_report_bytes) << "\n"; + } + ss << "\n"; + + buf = ss.str(); + fprintf(stdout, buf.data()); + fflush(stdout); + + offload_report_free_data(timer_data); +} + +extern void offload_report_free_data(OffloadHostTimerData * timer_data) +{ + OffloadHostTimerData *pnode_last = NULL; + + for (OffloadHostTimerData *pnode = timer_data_head; + pnode != 0; pnode = pnode->next) { + if (timer_data == pnode) { + if (pnode_last) { + pnode_last->next = pnode->next; + } + else { + timer_data_head = pnode->next; + } + OFFLOAD_FREE(pnode); + break; + } + pnode_last = pnode; + } +} + +static void fill_buf_with_spaces(std::stringstream &ss, int num) +{ + for (; num > 0; num--) { + ss << " "; + } +} + +static void offload_host_phase_name(std::stringstream &ss, int p_node) +{ + int prefix_spaces; + int str_length; + int tail_length; + const int message_length = 40; + char const *str; + + str = report_get_host_stage_str(p_node); + prefix_spaces = host_timer_prefix_spaces[p_node]; + fill_buf_with_spaces(ss, prefix_spaces); + str_length = strlen(str); + ss << str; + tail_length = message_length - prefix_spaces - str_length; + tail_length = tail_length > 0? tail_length : 1; + fill_buf_with_spaces(ss, tail_length); +} + +static void offload_target_phase_name(std::stringstream &ss, int p_node) +{ + int prefix_spaces; + int str_length; + const int message_length = 40; + int tail_length; + char const *str; + + str = report_get_target_stage_str(p_node); + prefix_spaces = target_timer_prefix_spaces[p_node]; + fill_buf_with_spaces(ss, prefix_spaces); + str_length = strlen(str); + ss << str; + tail_length = message_length - prefix_spaces - str_length; + tail_length = (tail_length > 0)? tail_length : 1; + fill_buf_with_spaces(ss, tail_length); +} + +void offload_timer_start(OffloadHostTimerData * timer_data, + OffloadHostPhase p_type) +{ + timer_data->phases[p_type].start = _rdtsc(); +} + +void offload_timer_stop(OffloadHostTimerData * timer_data, + OffloadHostPhase p_type) +{ + timer_data->phases[p_type].total += _rdtsc() - + timer_data->phases[p_type].start; +} + +void offload_timer_fill_target_data(OffloadHostTimerData * timer_data, + void *buf) +{ + uint64_t *data = (uint64_t*) buf; + + timer_data->target.frequency = *data++; + for (int i = 0; i < c_offload_target_max_phase; i++) { + timer_data->target.phases[i].total = *data++; + } +} + +void offload_timer_fill_host_sdata(OffloadHostTimerData * timer_data, + uint64_t sent_bytes) +{ + if (timer_data) { + timer_data->sent_bytes += sent_bytes; + } +} + +void offload_timer_fill_host_rdata(OffloadHostTimerData * timer_data, + uint64_t received_bytes) +{ + if (timer_data) { + timer_data->received_bytes += received_bytes; + } +} + +void offload_timer_fill_host_mic_num(OffloadHostTimerData * timer_data, + int card_number) +{ + if (timer_data) { + timer_data->card_number = card_number; + } +} + +OffloadHostTimerData* offload_timer_init(const char *file, int line) +{ + static bool first_time = true; + OffloadHostTimerData* timer_data = NULL; + + timer_data_mutex.lock(); + { + if (timer_enabled || + (offload_report_level && offload_report_enabled)) { + timer_data = (OffloadHostTimerData*) + OFFLOAD_MALLOC(sizeof(OffloadHostTimerData), 0); + memset(timer_data, 0, sizeof(OffloadHostTimerData)); + + timer_data->offload_number = OFFLOAD_DEBUG_INCR_OFLD_NUM() - 1; + + if (timer_data_head == 0) { + timer_data_head = timer_data; + timer_data_tail = timer_data; + } + else { + timer_data_tail->next = timer_data; + timer_data_tail = timer_data; + } + + timer_data->file = file; + timer_data->line = line; + } + } + timer_data_mutex.unlock(); + return timer_data; +} + +#endif // TIMING_SUPPORT -- cgit v1.1