[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

1 files changed, 379 insertions, 0 deletions

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 <ia32intrin.h>
+#else // __INTEL_COMPILER
+#include <x86intrin.h>
+#endif // __INTEL_COMPILER
+
+#include "offload_host.h"
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+
+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