//===----------------------------------------------------------------------===//
//
//                     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.
//
//===----------------------------------------------------------------------===//


// The COI host interface

#include "coi_client.h"
#include "../offload_common.h"

namespace COI {

#define COI_VERSION1    "COI_1.0"
#define COI_VERSION2    "COI_2.0"

bool            is_available;
static void*    lib_handle;

// pointers to functions from COI library
COIRESULT (*EngineGetCount)(COI_ISA_TYPE, uint32_t*);
COIRESULT (*EngineGetHandle)(COI_ISA_TYPE, uint32_t, COIENGINE*);

COIRESULT (*ProcessCreateFromMemory)(COIENGINE, const char*, const void*,
                                     uint64_t, int, const char**, uint8_t,
                                     const char**, uint8_t, const char*,
                                     uint64_t, const char*, const char*,
                                     uint64_t, COIPROCESS*);
COIRESULT (*ProcessDestroy)(COIPROCESS, int32_t, uint8_t, int8_t*, uint32_t*);
COIRESULT (*ProcessGetFunctionHandles)(COIPROCESS, uint32_t, const char**,
                                       COIFUNCTION*);
COIRESULT (*ProcessLoadLibraryFromMemory)(COIPROCESS, const void*, uint64_t,
                                          const char*, const char*,
                                          const char*, uint64_t, uint32_t,
                                          COILIBRARY*);
COIRESULT (*ProcessRegisterLibraries)(uint32_t, const void**, const uint64_t*,
                                      const char**, const uint64_t*);

COIRESULT (*PipelineCreate)(COIPROCESS, COI_CPU_MASK, uint32_t, COIPIPELINE*);
COIRESULT (*PipelineDestroy)(COIPIPELINE);
COIRESULT (*PipelineRunFunction)(COIPIPELINE, COIFUNCTION, uint32_t,
                                 const COIBUFFER*, const COI_ACCESS_FLAGS*,
                                 uint32_t, const COIEVENT*, const void*,
                                 uint16_t, void*, uint16_t, COIEVENT*);

COIRESULT (*BufferCreate)(uint64_t, COI_BUFFER_TYPE, uint32_t, const void*,
                          uint32_t, const COIPROCESS*, COIBUFFER*);
COIRESULT (*BufferCreateFromMemory)(uint64_t, COI_BUFFER_TYPE, uint32_t,
                                    void*, uint32_t, const COIPROCESS*,
                                    COIBUFFER*);
COIRESULT (*BufferDestroy)(COIBUFFER);
COIRESULT (*BufferMap)(COIBUFFER, uint64_t, uint64_t, COI_MAP_TYPE, uint32_t,
                       const COIEVENT*, COIEVENT*, COIMAPINSTANCE*, void**);
COIRESULT (*BufferUnmap)(COIMAPINSTANCE, uint32_t, const COIEVENT*, COIEVENT*);
COIRESULT (*BufferWrite)(COIBUFFER, uint64_t, const void*, uint64_t,
                         COI_COPY_TYPE, uint32_t, const COIEVENT*, COIEVENT*);
COIRESULT (*BufferRead)(COIBUFFER, uint64_t, void*, uint64_t, COI_COPY_TYPE,
                        uint32_t, const COIEVENT*, COIEVENT*);
COIRESULT (*BufferCopy)(COIBUFFER, COIBUFFER, uint64_t, uint64_t, uint64_t,
                        COI_COPY_TYPE, uint32_t, const COIEVENT*, COIEVENT*);
COIRESULT (*BufferGetSinkAddress)(COIBUFFER, uint64_t*);
COIRESULT (*BufferSetState)(COIBUFFER, COIPROCESS, COI_BUFFER_STATE,
                            COI_BUFFER_MOVE_FLAG, uint32_t,
                            const   COIEVENT*, COIEVENT*);

COIRESULT (*EventWait)(uint16_t, const COIEVENT*, int32_t, uint8_t, uint32_t*,
                       uint32_t*);

uint64_t  (*PerfGetCycleFrequency)(void);

bool init(void)
{
#ifndef TARGET_WINNT
    const char *lib_name = "libcoi_host.so.0";
#else // TARGET_WINNT
    const char *lib_name = "coi_host.dll";
#endif // TARGET_WINNT

    OFFLOAD_DEBUG_TRACE(2, "Loading COI library %s ...\n", lib_name);
    lib_handle = DL_open(lib_name);
    if (lib_handle == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to load the library\n");
        return false;
    }

    EngineGetCount =
        (COIRESULT (*)(COI_ISA_TYPE, uint32_t*))
            DL_sym(lib_handle, "COIEngineGetCount", COI_VERSION1);
    if (EngineGetCount == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIEngineGetCount");
        fini();
        return false;
    }

    EngineGetHandle =
        (COIRESULT (*)(COI_ISA_TYPE, uint32_t, COIENGINE*))
            DL_sym(lib_handle, "COIEngineGetHandle", COI_VERSION1);
    if (EngineGetHandle == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIEngineGetHandle");
        fini();
        return false;
    }

    ProcessCreateFromMemory =
        (COIRESULT (*)(COIENGINE, const char*, const void*, uint64_t, int,
                       const char**, uint8_t, const char**, uint8_t,
                       const char*, uint64_t, const char*, const char*,
                       uint64_t, COIPROCESS*))
            DL_sym(lib_handle, "COIProcessCreateFromMemory", COI_VERSION1);
    if (ProcessCreateFromMemory == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIProcessCreateFromMemory");
        fini();
        return false;
    }

    ProcessDestroy =
        (COIRESULT (*)(COIPROCESS, int32_t, uint8_t, int8_t*,
                       uint32_t*))
            DL_sym(lib_handle, "COIProcessDestroy", COI_VERSION1);
    if (ProcessDestroy == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIProcessDestroy");
        fini();
        return false;
    }

    ProcessGetFunctionHandles =
        (COIRESULT (*)(COIPROCESS, uint32_t, const char**, COIFUNCTION*))
            DL_sym(lib_handle, "COIProcessGetFunctionHandles", COI_VERSION1);
    if (ProcessGetFunctionHandles == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIProcessGetFunctionHandles");
        fini();
        return false;
    }

    ProcessLoadLibraryFromMemory =
        (COIRESULT (*)(COIPROCESS, const void*, uint64_t, const char*,
                       const char*, const char*, uint64_t, uint32_t,
                       COILIBRARY*))
            DL_sym(lib_handle, "COIProcessLoadLibraryFromMemory", COI_VERSION2);
    if (ProcessLoadLibraryFromMemory == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIProcessLoadLibraryFromMemory");
        fini();
        return false;
    }

    ProcessRegisterLibraries =
        (COIRESULT (*)(uint32_t, const void**, const uint64_t*, const char**,
                       const uint64_t*))
            DL_sym(lib_handle, "COIProcessRegisterLibraries", COI_VERSION1);
    if (ProcessRegisterLibraries == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIProcessRegisterLibraries");
        fini();
        return false;
    }

    PipelineCreate =
        (COIRESULT (*)(COIPROCESS, COI_CPU_MASK, uint32_t, COIPIPELINE*))
            DL_sym(lib_handle, "COIPipelineCreate", COI_VERSION1);
    if (PipelineCreate == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIPipelineCreate");
        fini();
        return false;
    }

    PipelineDestroy =
        (COIRESULT (*)(COIPIPELINE))
            DL_sym(lib_handle, "COIPipelineDestroy", COI_VERSION1);
    if (PipelineDestroy == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIPipelineDestroy");
        fini();
        return false;
    }

    PipelineRunFunction =
        (COIRESULT (*)(COIPIPELINE, COIFUNCTION, uint32_t, const COIBUFFER*,
                       const COI_ACCESS_FLAGS*, uint32_t, const COIEVENT*,
                       const void*, uint16_t, void*, uint16_t, COIEVENT*))
            DL_sym(lib_handle, "COIPipelineRunFunction", COI_VERSION1);
    if (PipelineRunFunction == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIPipelineRunFunction");
        fini();
        return false;
    }

    BufferCreate =
        (COIRESULT (*)(uint64_t, COI_BUFFER_TYPE, uint32_t, const void*,
                       uint32_t, const COIPROCESS*, COIBUFFER*))
            DL_sym(lib_handle, "COIBufferCreate", COI_VERSION1);
    if (BufferCreate == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferCreate");
        fini();
        return false;
    }

    BufferCreateFromMemory =
        (COIRESULT (*)(uint64_t, COI_BUFFER_TYPE, uint32_t, void*,
                       uint32_t, const COIPROCESS*, COIBUFFER*))
            DL_sym(lib_handle, "COIBufferCreateFromMemory", COI_VERSION1);
    if (BufferCreateFromMemory == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferCreateFromMemory");
        fini();
        return false;
    }

    BufferDestroy =
        (COIRESULT (*)(COIBUFFER))
            DL_sym(lib_handle, "COIBufferDestroy", COI_VERSION1);
    if (BufferDestroy == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferDestroy");
        fini();
        return false;
    }

    BufferMap =
        (COIRESULT (*)(COIBUFFER, uint64_t, uint64_t, COI_MAP_TYPE, uint32_t,
                       const COIEVENT*, COIEVENT*, COIMAPINSTANCE*,
                       void**))
            DL_sym(lib_handle, "COIBufferMap", COI_VERSION1);
    if (BufferMap == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferMap");
        fini();
        return false;
    }

    BufferUnmap =
        (COIRESULT (*)(COIMAPINSTANCE, uint32_t, const COIEVENT*,
                       COIEVENT*))
            DL_sym(lib_handle, "COIBufferUnmap", COI_VERSION1);
    if (BufferUnmap == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferUnmap");
        fini();
        return false;
    }

    BufferWrite =
        (COIRESULT (*)(COIBUFFER, uint64_t, const void*, uint64_t,
                       COI_COPY_TYPE, uint32_t, const COIEVENT*,
                       COIEVENT*))
            DL_sym(lib_handle, "COIBufferWrite", COI_VERSION1);
    if (BufferWrite == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferWrite");
        fini();
        return false;
    }

    BufferRead =
        (COIRESULT (*)(COIBUFFER, uint64_t, void*, uint64_t,
                                     COI_COPY_TYPE, uint32_t,
                                     const COIEVENT*, COIEVENT*))
            DL_sym(lib_handle, "COIBufferRead", COI_VERSION1);
    if (BufferRead == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferRead");
        fini();
        return false;
    }

    BufferCopy =
        (COIRESULT (*)(COIBUFFER, COIBUFFER, uint64_t, uint64_t, uint64_t,
                       COI_COPY_TYPE, uint32_t, const COIEVENT*,
                       COIEVENT*))
            DL_sym(lib_handle, "COIBufferCopy", COI_VERSION1);
    if (BufferCopy == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferCopy");
        fini();
        return false;
    }

    BufferGetSinkAddress =
        (COIRESULT (*)(COIBUFFER, uint64_t*))
            DL_sym(lib_handle, "COIBufferGetSinkAddress", COI_VERSION1);
    if (BufferGetSinkAddress == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferGetSinkAddress");
        fini();
        return false;
    }

    BufferSetState =
        (COIRESULT(*)(COIBUFFER, COIPROCESS, COI_BUFFER_STATE,
                      COI_BUFFER_MOVE_FLAG, uint32_t, const COIEVENT*,
                      COIEVENT*))
            DL_sym(lib_handle, "COIBufferSetState", COI_VERSION1);
    if (BufferSetState == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIBufferSetState");
        fini();
        return false;
    }

    EventWait =
        (COIRESULT (*)(uint16_t, const COIEVENT*, int32_t, uint8_t,
                       uint32_t*, uint32_t*))
            DL_sym(lib_handle, "COIEventWait", COI_VERSION1);
    if (EventWait == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIEventWait");
        fini();
        return false;
    }

    PerfGetCycleFrequency =
        (uint64_t (*)(void))
            DL_sym(lib_handle, "COIPerfGetCycleFrequency", COI_VERSION1);
    if (PerfGetCycleFrequency == 0) {
        OFFLOAD_DEBUG_TRACE(2, "Failed to find %s in COI library\n",
                            "COIPerfGetCycleFrequency");
        fini();
        return false;
    }

    is_available = true;

    return true;
}

void fini(void)
{
    is_available = false;

    if (lib_handle != 0) {
#ifndef TARGET_WINNT
        DL_close(lib_handle);
#endif // TARGET_WINNT
        lib_handle = 0;
    }
}

} // namespace COI