Remove liboffload from repository

See the mailing list for the proposal and discussion:
http://lists.llvm.org/pipermail/openmp-dev/2018-June/002041.html

llvm-svn: 335069

1 files changed, 0 insertions, 531 deletions

diff --git a/openmp/offload/src/offload_engine.cpp b/openmp/offload/src/offload_engine.cpp
deleted file mode 100644
index 069b604e1ea..00000000000
--- a/openmp/offload/src/offload_engine.cpp
+++ /dev/null
@@ -1,531 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.txt for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-#include "offload_engine.h"
-#include <signal.h>
-#include <errno.h>
-
-#include <algorithm>
-#include <vector>
-
-#include "offload_host.h"
-#include "offload_table.h"
-
-const char* Engine::m_func_names[Engine::c_funcs_total] =
-{
-    "server_compute",
-#ifdef MYO_SUPPORT
-    "server_myoinit",
-    "server_myofini",
-#endif // MYO_SUPPORT
-    "server_init",
-    "server_var_table_size",
-    "server_var_table_copy"
-};
-
-// Symbolic representation of system signals. Fix for CQ233593
-const char* Engine::c_signal_names[Engine::c_signal_max] =
-{
-    "Unknown SIGNAL",
-    "SIGHUP",    /*  1, Hangup (POSIX).  */
-    "SIGINT",    /*  2, Interrupt (ANSI).  */
-    "SIGQUIT",   /*  3, Quit (POSIX).  */
-    "SIGILL",    /*  4, Illegal instruction (ANSI).  */
-    "SIGTRAP",   /*  5, Trace trap (POSIX).  */
-    "SIGABRT",   /*  6, Abort (ANSI).  */
-    "SIGBUS",    /*  7, BUS error (4.2 BSD).  */
-    "SIGFPE",    /*  8, Floating-point exception (ANSI).  */
-    "SIGKILL",   /*  9, Kill, unblockable (POSIX).  */
-    "SIGUSR1",   /* 10, User-defined signal 1 (POSIX).  */
-    "SIGSEGV",   /* 11, Segmentation violation (ANSI).  */
-    "SIGUSR2",   /* 12, User-defined signal 2 (POSIX).  */
-    "SIGPIPE",   /* 13, Broken pipe (POSIX).  */
-    "SIGALRM",   /* 14, Alarm clock (POSIX).  */
-    "SIGTERM",   /* 15, Termination (ANSI).  */
-    "SIGSTKFLT", /* 16, Stack fault.  */
-    "SIGCHLD",   /* 17, Child status has changed (POSIX).  */
-    "SIGCONT",   /* 18, Continue (POSIX).  */
-    "SIGSTOP",   /* 19, Stop, unblockable (POSIX).  */
-    "SIGTSTP",   /* 20, Keyboard stop (POSIX).  */
-    "SIGTTIN",   /* 21, Background read from tty (POSIX).  */
-    "SIGTTOU",   /* 22, Background write to tty (POSIX).  */
-    "SIGURG",    /* 23, Urgent condition on socket (4.2 BSD).  */
-    "SIGXCPU",   /* 24, CPU limit exceeded (4.2 BSD).  */
-    "SIGXFSZ",   /* 25, File size limit exceeded (4.2 BSD).  */
-    "SIGVTALRM", /* 26, Virtual alarm clock (4.2 BSD).  */
-    "SIGPROF",   /* 27, Profiling alarm clock (4.2 BSD).  */
-    "SIGWINCH",  /* 28, Window size change (4.3 BSD, Sun).  */
-    "SIGIO",     /* 29, I/O now possible (4.2 BSD).  */
-    "SIGPWR",    /* 30, Power failure restart (System V).  */
-    "SIGSYS"     /* 31, Bad system call.  */
-};
-
-void Engine::init(void)
-{
-    if (!m_ready) {
-        mutex_locker_t locker(m_lock);
-
-        if (!m_ready) {
-            // start process if not done yet
-            if (m_process == 0) {
-                init_process();
-            }
-
-            // load penging images
-            load_libraries();
-
-            // and (re)build pointer table
-            init_ptr_data();
-
-            // it is ready now
-            m_ready = true;
-        }
-    }
-}
-
-void Engine::init_process(void)
-{
-    COIENGINE engine;
-    COIRESULT res;
-    const char **environ;
-
-    // create environment for the target process
-    environ = (const char**) mic_env_vars.create_environ_for_card(m_index);
-    if (environ != 0) {
-        for (const char **p = environ; *p != 0; p++) {
-            OFFLOAD_DEBUG_TRACE(3, "Env Var for card %d: %s\n", m_index, *p);
-        }
-    }
-
-    // Create execution context in the specified device
-    OFFLOAD_DEBUG_TRACE(2, "Getting device %d (engine %d) handle\n", m_index,
-                        m_physical_index);
-    res = COI::EngineGetHandle(COI_ISA_KNC, m_physical_index, &engine);
-    check_result(res, c_get_engine_handle, m_index, res);
-
-    // Target executable should be available by the time when we
-    // attempt to initialize the device
-    if (__target_exe == 0) {
-        LIBOFFLOAD_ERROR(c_no_target_exe);
-        exit(1);
-    }
-
-    OFFLOAD_DEBUG_TRACE(2,
-        "Loading target executable \"%s\" from %p, size %lld\n",
-        __target_exe->name, __target_exe->data, __target_exe->size);
-
-    res = COI::ProcessCreateFromMemory(
-        engine,                 // in_Engine
-        __target_exe->name,     // in_pBinaryName
-        __target_exe->data,     // in_pBinaryBuffer
-        __target_exe->size,     // in_BinaryBufferLength,
-        0,                      // in_Argc
-        0,                      // in_ppArgv
-        environ == 0,           // in_DupEnv
-        environ,                // in_ppAdditionalEnv
-        mic_proxy_io,           // in_ProxyActive
-        mic_proxy_fs_root,      // in_ProxyfsRoot
-        mic_buffer_size,        // in_BufferSpace
-        mic_library_path,       // in_LibrarySearchPath
-        __target_exe->origin,   // in_FileOfOrigin
-        __target_exe->offset,   // in_FileOfOriginOffset
-        &m_process              // out_pProcess
-    );
-    check_result(res, c_process_create, m_index, res);
-
-    // get function handles
-    res = COI::ProcessGetFunctionHandles(m_process, c_funcs_total,
-                                         m_func_names, m_funcs);
-    check_result(res, c_process_get_func_handles, m_index, res);
-
-    // initialize device side
-    pid_t pid = init_device();
-
-    // For IDB
-    if (__dbg_is_attached) {
-        // TODO: we have in-memory executable now.
-        // Check with IDB team what should we provide them now?
-        if (strlen(__target_exe->name) < MAX_TARGET_NAME) {
-            strcpy(__dbg_target_exe_name, __target_exe->name);
-        }
-        __dbg_target_so_pid = pid;
-        __dbg_target_id = m_physical_index;
-        __dbg_target_so_loaded();
-    }
-}
-
-void Engine::fini_process(bool verbose)
-{
-    if (m_process != 0) {
-        uint32_t sig;
-        int8_t ret;
-
-        // destroy target process
-        OFFLOAD_DEBUG_TRACE(2, "Destroying process on the device %d\n",
-                            m_index);
-
-        COIRESULT res = COI::ProcessDestroy(m_process, -1, 0, &ret, &sig);
-        m_process = 0;
-
-        if (res == COI_SUCCESS) {
-            OFFLOAD_DEBUG_TRACE(3, "Device process: signal %d, exit code %d\n",
-                                sig, ret);
-            if (verbose) {
-                if (sig != 0) {
-                    LIBOFFLOAD_ERROR(
-                        c_mic_process_exit_sig, m_index, sig,
-                        c_signal_names[sig >= c_signal_max ? 0 : sig]);
-                }
-                else {
-                    LIBOFFLOAD_ERROR(c_mic_process_exit_ret, m_index, ret);
-                }
-            }
-
-            // for idb
-            if (__dbg_is_attached) {
-                __dbg_target_so_unloaded();
-            }
-        }
-        else {
-            if (verbose) {
-                LIBOFFLOAD_ERROR(c_mic_process_exit, m_index);
-            }
-        }
-    }
-}
-
-void Engine::load_libraries()
-{
-    // load libraries collected so far
-    for (TargetImageList::iterator it = m_images.begin();
-         it != m_images.end(); it++) {
-        OFFLOAD_DEBUG_TRACE(2, "Loading library \"%s\" from %p, size %llu\n",
-                            it->name, it->data, it->size);
-
-        // load library to the device
-        COILIBRARY lib;
-        COIRESULT res;
-        res = COI::ProcessLoadLibraryFromMemory(m_process,
-                                                it->data,
-                                                it->size,
-                                                it->name,
-                                                mic_library_path,
-                                                it->origin,
-                                                it->offset,
-                                                COI_LOADLIBRARY_V1_FLAGS,
-                                                &lib);
-
-        if (res != COI_SUCCESS && res != COI_ALREADY_EXISTS) {
-            check_result(res, c_load_library, m_index, res);
-        }
-    }
-    m_images.clear();
-}
-
-static bool target_entry_cmp(
-    const VarList::BufEntry &l,
-    const VarList::BufEntry &r
-)
-{
-    const char *l_name = reinterpret_cast<const char*>(l.name);
-    const char *r_name = reinterpret_cast<const char*>(r.name);
-    return strcmp(l_name, r_name) < 0;
-}
-
-static bool host_entry_cmp(
-    const VarTable::Entry *l,
-    const VarTable::Entry *r
-)
-{
-    return strcmp(l->name, r->name) < 0;
-}
-
-void Engine::init_ptr_data(void)
-{
-    COIRESULT res;
-    COIEVENT event;
-
-    // Prepare table of host entries
-    std::vector<const VarTable::Entry*> host_table(__offload_vars.begin(),
-                                                   __offload_vars.end());
-
-    // no need to do anything further is host table is empty
-    if (host_table.size() <= 0) {
-        return;
-    }
-
-    // Get var table entries from the target.
-    // First we need to get size for the buffer to copy data
-    struct {
-        int64_t nelems;
-        int64_t length;
-    } params;
-
-    res = COI::PipelineRunFunction(get_pipeline(),
-                                   m_funcs[c_func_var_table_size],
-                                   0, 0, 0,
-                                   0, 0,
-                                   0, 0,
-                                   &params, sizeof(params),
-                                   &event);
-    check_result(res, c_pipeline_run_func, m_index, res);
-
-    res = COI::EventWait(1, &event, -1, 1, 0, 0);
-    check_result(res, c_event_wait, res);
-
-    if (params.length == 0) {
-        return;
-    }
-
-    // create buffer for target entries and copy data to host
-    COIBUFFER buffer;
-    res = COI::BufferCreate(params.length, COI_BUFFER_NORMAL, 0, 0, 1,
-                            &m_process, &buffer);
-    check_result(res, c_buf_create, m_index, res);
-
-    COI_ACCESS_FLAGS flags = COI_SINK_WRITE;
-    res = COI::PipelineRunFunction(get_pipeline(),
-                                   m_funcs[c_func_var_table_copy],
-                                   1, &buffer, &flags,
-                                   0, 0,
-                                   &params.nelems, sizeof(params.nelems),
-                                   0, 0,
-                                   &event);
-    check_result(res, c_pipeline_run_func, m_index, res);
-
-    res = COI::EventWait(1, &event, -1, 1, 0, 0);
-    check_result(res, c_event_wait, res);
-
-    // patch names in target data
-    VarList::BufEntry *target_table;
-    COIMAPINSTANCE map_inst;
-    res = COI::BufferMap(buffer, 0, params.length, COI_MAP_READ_ONLY, 0, 0,
-                         0, &map_inst,
-                         reinterpret_cast<void**>(&target_table));
-    check_result(res, c_buf_map, res);
-
-    VarList::table_patch_names(target_table, params.nelems);
-
-    // and sort entries
-    std::sort(target_table, target_table + params.nelems, target_entry_cmp);
-    std::sort(host_table.begin(), host_table.end(), host_entry_cmp);
-
-    // merge host and target entries and enter matching vars map
-    std::vector<const VarTable::Entry*>::const_iterator hi =
-        host_table.begin();
-    std::vector<const VarTable::Entry*>::const_iterator he =
-        host_table.end();
-    const VarList::BufEntry *ti = target_table;
-    const VarList::BufEntry *te = target_table + params.nelems;
-
-    while (hi != he && ti != te) {
-        int res = strcmp((*hi)->name, reinterpret_cast<const char*>(ti->name));
-        if (res == 0) {
-            // add matching entry to var map
-            std::pair<PtrSet::iterator, bool> res =
-                m_ptr_set.insert(PtrData((*hi)->addr, (*hi)->size));
-
-            // store address for new entries
-            if (res.second) {
-                PtrData *ptr = const_cast<PtrData*>(res.first.operator->());
-                ptr->mic_addr = ti->addr;
-                ptr->is_static = true;
-            }
-
-            hi++;
-            ti++;
-        }
-        else if (res < 0) {
-            hi++;
-        }
-        else {
-            ti++;
-        }
-    }
-
-    // cleanup
-    res = COI::BufferUnmap(map_inst, 0, 0, 0);
-    check_result(res, c_buf_unmap, res);
-
-    res = COI::BufferDestroy(buffer);
-    check_result(res, c_buf_destroy, res);
-}
-
-COIRESULT Engine::compute(
-    const std::list<COIBUFFER> &buffers,
-    const void*         data,
-    uint16_t            data_size,
-    void*               ret,
-    uint16_t            ret_size,
-    uint32_t            num_deps,
-    const COIEVENT*     deps,
-    COIEVENT*           event
-) /* const */
-{
-    COIBUFFER *bufs;
-    COI_ACCESS_FLAGS *flags;
-    COIRESULT res;
-
-    // convert buffers list to array
-    int num_bufs = buffers.size();
-    if (num_bufs > 0) {
-        bufs = (COIBUFFER*) alloca(num_bufs * sizeof(COIBUFFER));
-        flags = (COI_ACCESS_FLAGS*) alloca(num_bufs *
-                                           sizeof(COI_ACCESS_FLAGS));
-
-        int i = 0;
-        for (std::list<COIBUFFER>::const_iterator it = buffers.begin();
-             it != buffers.end(); it++) {
-            bufs[i] = *it;
-
-            // TODO: this should be fixed
-            flags[i++] = COI_SINK_WRITE;
-        }
-    }
-    else {
-        bufs = 0;
-        flags = 0;
-    }
-
-    // start computation
-    res = COI::PipelineRunFunction(get_pipeline(),
-                                   m_funcs[c_func_compute],
-                                   num_bufs, bufs, flags,
-                                   num_deps, deps,
-                                   data, data_size,
-                                   ret, ret_size,
-                                   event);
-    return res;
-}
-
-pid_t Engine::init_device(void)
-{
-    struct init_data {
-        int  device_index;
-        int  devices_total;
-        int  console_level;
-        int  offload_report_level;
-    } data;
-    COIRESULT res;
-    COIEVENT event;
-    pid_t pid;
-
-    OFFLOAD_DEBUG_TRACE_1(2, 0, c_offload_init,
-                          "Initializing device with logical index %d "
-                          "and physical index %d\n",
-                           m_index, m_physical_index);
-
-    // setup misc data
-    data.device_index = m_index;
-    data.devices_total = mic_engines_total;
-    data.console_level = console_enabled;
-    data.offload_report_level = offload_report_level;
-
-    res = COI::PipelineRunFunction(get_pipeline(),
-                                   m_funcs[c_func_init],
-                                   0, 0, 0, 0, 0,
-                                   &data, sizeof(data),
-                                   &pid, sizeof(pid),
-                                   &event);
-    check_result(res, c_pipeline_run_func, m_index, res);
-
-    res = COI::EventWait(1, &event, -1, 1, 0, 0);
-    check_result(res, c_event_wait, res);
-
-    OFFLOAD_DEBUG_TRACE(2, "Device process pid is %d\n", pid);
-
-    return pid;
-}
-
-// data associated with each thread
-struct Thread {
-    Thread(long* addr_coipipe_counter) {
-        m_addr_coipipe_counter = addr_coipipe_counter;
-        memset(m_pipelines, 0, sizeof(m_pipelines));
-    }
-
-    ~Thread() {
-#ifndef TARGET_WINNT
-        __sync_sub_and_fetch(m_addr_coipipe_counter, 1);
-#else // TARGET_WINNT
-        _InterlockedDecrement(m_addr_coipipe_counter);
-#endif // TARGET_WINNT
-        for (int i = 0; i < mic_engines_total; i++) {
-            if (m_pipelines[i] != 0) {
-                COI::PipelineDestroy(m_pipelines[i]);
-            }
-        }
-    }
-
-    COIPIPELINE get_pipeline(int index) const {
-        return m_pipelines[index];
-    }
-
-    void set_pipeline(int index, COIPIPELINE pipeline) {
-        m_pipelines[index] = pipeline;
-    }
-
-    AutoSet& get_auto_vars() {
-        return m_auto_vars;
-    }
-
-private:
-    long*       m_addr_coipipe_counter;
-    AutoSet     m_auto_vars;
-    COIPIPELINE m_pipelines[MIC_ENGINES_MAX];
-};
-
-COIPIPELINE Engine::get_pipeline(void)
-{
-    Thread* thread = (Thread*) thread_getspecific(mic_thread_key);
-    if (thread == 0) {
-        thread = new Thread(&m_proc_number);
-        thread_setspecific(mic_thread_key, thread);
-    }
-
-    COIPIPELINE pipeline = thread->get_pipeline(m_index);
-    if (pipeline == 0) {
-        COIRESULT res;
-        int proc_num;
-
-#ifndef TARGET_WINNT
-        proc_num = __sync_fetch_and_add(&m_proc_number, 1);
-#else // TARGET_WINNT
-        proc_num = _InterlockedIncrement(&m_proc_number);
-#endif // TARGET_WINNT
-
-        if (proc_num > COI_PIPELINE_MAX_PIPELINES) {
-            LIBOFFLOAD_ERROR(c_coipipe_max_number, COI_PIPELINE_MAX_PIPELINES);
-            LIBOFFLOAD_ABORT;
-        }
-        // create pipeline for this thread
-        res = COI::PipelineCreate(m_process, 0, mic_stack_size, &pipeline);
-        check_result(res, c_pipeline_create, m_index, res);
-
-        thread->set_pipeline(m_index, pipeline);
-    }
-    return pipeline;
-}
-
-AutoSet& Engine::get_auto_vars(void)
-{
-    Thread* thread = (Thread*) thread_getspecific(mic_thread_key);
-    if (thread == 0) {
-        thread = new Thread(&m_proc_number);
-        thread_setspecific(mic_thread_key, thread);
-    }
-
-    return thread->get_auto_vars();
-}
-
-void Engine::destroy_thread_data(void *data)
-{
-    delete static_cast<Thread*>(data);
-}