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


/*! \file
    \brief The parts of the runtime library used only on the host
*/

#ifndef OFFLOAD_HOST_H_INCLUDED
#define OFFLOAD_HOST_H_INCLUDED

#ifndef TARGET_WINNT
#include <unistd.h>
#endif // TARGET_WINNT
#include "offload_common.h"
#include "offload_util.h"
#include "offload_engine.h"
#include "offload_env.h"
#include "offload_orsl.h"
#include "coi/coi_client.h"

// MIC engines.
DLL_LOCAL extern Engine*  mic_engines;
DLL_LOCAL extern uint32_t mic_engines_total;

// DMA channel count used by COI and set via
// OFFLOAD_DMA_CHANNEL_COUNT environment variable
DLL_LOCAL extern uint32_t mic_dma_channel_count;

//! The target image is packed as follows.
/*!      1. 8 bytes containing the size of the target binary          */
/*!      2. a null-terminated string which is the binary name         */
/*!      3. <size> number of bytes that are the contents of the image */
/*!      The address of symbol __offload_target_image
             is the address of this structure.                        */
struct Image {
     int64_t size; //!< Size in bytes of the target binary name and contents
     char data[];  //!< The name and contents of the target image
};

// The offload descriptor.
class OffloadDescriptor
{
public:
    enum  OmpAsyncLastEventType {
        c_last_not,     // not last event
        c_last_write,   // the last event that is write
        c_last_read,    // the last event that is read
        c_last_runfunc  // the last event that is runfunction
    };
    
    OffloadDescriptor(
        int index,
        _Offload_status *status,
        bool is_mandatory,
        bool is_openmp,
        OffloadHostTimerData * timer_data
    ) :
        m_device(mic_engines[index == -1 ? 0 : index % mic_engines_total]),
        m_is_mandatory(is_mandatory),
        m_is_openmp(is_openmp),
        m_inout_buf(0),
        m_func_desc(0),
        m_func_desc_size(0),
        m_num_in_dependencies(0),
        m_p_in_dependencies(0),
        m_in_deps(0),
        m_in_deps_total(0),
        m_in_deps_allocated(0),        
        m_out_deps(0),
        m_out_deps_total(0),
        m_out_deps_allocated(0),
        m_vars(0),
        m_vars_extra(0),
        m_status(status),
        m_timer_data(timer_data),
        m_out_with_preallocated(false),
        m_preallocated_alloc(false),
        m_traceback_called(false),
        m_stream(-1),
        m_signal(0),
        m_has_signal(0),
        m_omp_async_last_event_type(c_last_not)
    {
        m_wait_all_devices = index == -1;
    }

    ~OffloadDescriptor()
    {
        if (m_in_deps != 0) {
            free(m_in_deps);
        }
        if (m_out_deps != 0) {
            free(m_out_deps);
        }
        if (m_func_desc != 0) {
            free(m_func_desc);
        }
        if (m_vars != 0) {
            free(m_vars);
            free(m_vars_extra);
        }
    }

    bool offload(const char *name, bool is_empty,
                 VarDesc *vars, VarDesc2 *vars2, int vars_total,
                 const void **waits, int num_waits, const void **signal,
                 int entry_id, const void *stack_addr,
                 OffloadFlags offload_flags);

    bool offload_finish(bool is_traceback);

    bool is_signaled();

    OffloadHostTimerData* get_timer_data() const {
        return m_timer_data;
    }

    void set_stream(_Offload_stream stream) {
        m_stream = stream;
    }

    _Offload_stream get_stream() {
        return(m_stream);
    }

    Engine& get_device() {
        return m_device;
    }

    void* get_signal() {
        return(m_signal);
    }

    void set_signal(const void* signal) {
        m_has_signal = 1;
        m_signal = const_cast<void*>(signal);
    }

    void cleanup();

    uint32_t  m_event_count;
    bool      m_has_signal;

private:
    bool offload_wrap(const char *name, bool is_empty,
                 VarDesc *vars, VarDesc2 *vars2, int vars_total,
                 const void **waits, int num_waits, const void **signal,
                 int entry_id, const void *stack_addr,
                 OffloadFlags offload_flags);
    bool wait_dependencies(const void **waits, int num_waits,
                           _Offload_stream stream);
    bool setup_descriptors(VarDesc *vars, VarDesc2 *vars2, int vars_total,
                           int entry_id, const void *stack_addr);
    bool setup_misc_data(const char *name);
    bool send_pointer_data(bool is_async, void* info);
    bool send_noncontiguous_pointer_data(
        int i,
        PtrData* src_buf,
        PtrData* dst_buf,
        COIEVENT *event,
        uint64_t  &sent_data,
        uint32_t in_deps_amount,
        COIEVENT *in_deps
        );
    bool receive_noncontiguous_pointer_data(
        int i,
        COIBUFFER dst_buf,
        COIEVENT *event,
        uint64_t  &received_data,
        uint32_t in_deps_amount,
        COIEVENT *in_deps
        );

    bool gather_copyin_data();

    bool compute(void *);

    bool receive_pointer_data(bool is_async, bool first_run, void * info);
    bool scatter_copyout_data();

    bool find_ptr_data(PtrData* &ptr_data, void *base, int64_t disp,
                       int64_t length, bool is_targptr,
                       bool error_does_not_exist = true);

    void find_device_ptr( int64_t* &device_ptr,
                       void *host_ptr);

    bool alloc_ptr_data(PtrData* &ptr_data, void *base, int64_t disp,
                        int64_t length, int64_t alloc_disp, int align,
                        bool is_targptr, bool is_prealloc, bool pin);
    bool create_preallocated_buffer(PtrData* ptr_data, void *base);
    bool init_static_ptr_data(PtrData *ptr_data);
    bool init_mic_address(PtrData *ptr_data);
    bool offload_stack_memory_manager(
        const void * stack_begin,
        int routine_id,
        int buf_size,
        int align,
        bool thread_specific_function_locals,
        bool *is_new);
    char *get_this_threads_cpu_stack_addr(
        const void * stack_begin,
        int routine_id,
        bool thread_specific_function_locals);
    PtrData *get_this_threads_mic_stack_addr(
        const void * stack_begin,
        int routine_id,
        bool thread_specific_function_locals);
    bool nullify_target_stack(COIBUFFER targ_buf, uint64_t size);

    bool gen_var_descs_for_pointer_array(int i);

    void get_stream_in_dependencies(uint32_t &in_deps_amount,
                                    COIEVENT* &in_deps);

    void report_coi_error(error_types msg, COIRESULT res);
    _Offload_result translate_coi_error(COIRESULT res) const;

    void setup_omp_async_info();

    void setup_use_device_ptr(int i);

    void register_event_call_back(void (*)(
                                      COIEVENT,
                                      const COIRESULT,
                                      const void*),
                                  const COIEVENT *event,
                                  const void *info);

    void register_omp_event_call_back(const COIEVENT *event, const void *info);

private:
    typedef std::list<COIBUFFER> BufferList;

    // extra data associated with each variable descriptor
    struct VarExtra {
        PtrData* src_data;
        PtrData* dst_data;
        AutoData* auto_data;
        int64_t cpu_disp;
        int64_t cpu_offset;
        void *alloc;
        union {
            CeanReadRanges *read_rng_src;
            NonContigDesc  *noncont_desc;
        };
        CeanReadRanges *read_rng_dst;
        int64_t ptr_arr_offset;
        bool is_arr_ptr_el;
        OmpAsyncLastEventType omp_last_event_type;
        int64_t pointer_offset;
        uint16_t type_src;
        uint16_t type_dst;
    };

    template<typename T> class ReadArrElements {
    public:
        ReadArrElements():
            ranges(NULL),
            el_size(sizeof(T)),
            offset(0),
            count(0),
            is_empty(true),
            base(NULL)
        {}

        bool read_next(bool flag)
        {
            if (flag != 0) {
                if (is_empty) {
                    if (ranges) {
                        if (!get_next_range(ranges, &offset)) {
                            // ranges are over
                            return false;
                        }
                    }
                    // all contiguous elements are over
                    else if (count != 0) {
                        return false;
                    }

                    length_cur = size;
                }
                else {
                    offset += el_size;
                }
                val = (T)get_el_value(base, offset, el_size);
                length_cur -= el_size;
                count++;
                is_empty = length_cur == 0;
            }
            return true;
        }
    public:
        CeanReadRanges * ranges;
        T       val;
        int     el_size;
        int64_t size,
                offset,
                length_cur;
        bool    is_empty;
        int     count;
        char   *base;
    };

    // ptr_data for persistent auto objects
    PtrData*    m_stack_ptr_data;
    PtrDataList m_destroy_stack;

    // Engine
    Engine& m_device;

    // true for offload_wait target(mic) stream(0)
    bool m_wait_all_devices;

    // if true offload is mandatory
    bool m_is_mandatory;

    // if true offload has openmp origin
    const bool m_is_openmp;

    // The Marshaller for the inputs of the offloaded region.
    Marshaller m_in;

    // The Marshaller for the outputs of the offloaded region.
    Marshaller m_out;

    // List of buffers that are passed to dispatch call
    BufferList m_compute_buffers;

    // List of buffers that need to be destroyed at the end of offload
    BufferList m_destroy_buffers;

    // Variable descriptors
    VarDesc*  m_vars;
    VarExtra* m_vars_extra;
    int       m_vars_total;

    // Pointer to a user-specified status variable
    _Offload_status *m_status;

    // Function descriptor
    FunctionDescriptor* m_func_desc;
    uint32_t            m_func_desc_size;

    // Buffer for transferring copyin/copyout data
    COIBUFFER m_inout_buf;


    // Dependencies
    COIEVENT *m_in_deps;
    uint32_t  m_in_deps_total;
    uint32_t  m_in_deps_allocated;    
    COIEVENT *m_out_deps;
    uint32_t  m_out_deps_total;
    uint32_t  m_out_deps_allocated;

    // 2 variables defines input dependencies for current COI API.
    // The calls to routines as BufferWrite/PipelineRunFunction/BufferRead
    // is supposed to have input dependencies.
    // 2 variables below defines the number and vector of dependencies
    // in every current moment of offload.
    // So any phase of offload can use its values as input dependencies 
    // for the COI API that the phase calls.
    // It means that all phases (of Write, RunFunction,Read) must keep
    // the variables correct to be used by following phase.
    // If some consequent offloads are connected (i.e. by the same stream)
    // the final 2 variables of the offload is used as initial inputs
    // for the next offload.
    uint32_t  m_num_in_dependencies;
    COIEVENT *m_p_in_dependencies;

    // Stream
    _Offload_stream m_stream;

    // Signal
    void* m_signal;

    // Timer data
    OffloadHostTimerData *m_timer_data;

    // copyin/copyout data length
    uint64_t m_in_datalen;
    uint64_t m_out_datalen;

    // a boolean value calculated in setup_descriptors. If true we need to do
    // a run function on the target. Otherwise it may be optimized away.
    bool m_need_runfunction;

    // initialized value of m_need_runfunction;
    // is used to recognize offload_transfer
    bool m_initial_need_runfunction;

    // a Boolean value set to true when OUT clauses with preallocated targetptr
    // is encountered to indicate that call receive_pointer_data needs to be
    // invoked again after call to scatter_copyout_data.
    bool m_out_with_preallocated;

    // a Boolean value set to true if an alloc_if(1) is used with preallocated
    // targetptr to indicate the need to scatter_copyout_data even for
    // async offload
    bool m_preallocated_alloc;

    // a Boolean value set to true if traceback routine is called
    bool m_traceback_called;  

    OmpAsyncLastEventType m_omp_async_last_event_type;
};

// Initialization types for MIC
enum OffloadInitType {
    c_init_on_start,         // all devices before entering main
    c_init_on_offload,       // single device before starting the first offload
    c_init_on_offload_all    // all devices before starting the first offload
};

// Determines if MIC code is an executable or a shared library
extern "C" bool __offload_target_image_is_executable(const void *target_image);

// Initializes library and registers specified offload image.
extern "C" bool __offload_register_image(const void* image);
extern "C" void __offload_unregister_image(const void* image);

// Registers asynchronous task completion callback
extern "C" void __offload_register_task_callback(void (*cb)(void *));

// Initializes offload runtime library.
DLL_LOCAL extern int __offload_init_library(void);

// thread data for associating pipelines with threads
DLL_LOCAL extern pthread_key_t mic_thread_key;

// location of offload_main executable
// To be used if the main application has no offload and is not built
// with -offload but dynamic library linked in has offload pragma
DLL_LOCAL extern char* mic_device_main;

// Environment variables for devices
DLL_LOCAL extern MicEnvVar mic_env_vars;

// CPU frequency
DLL_LOCAL extern uint64_t cpu_frequency;

// LD_LIBRARY_PATH for KNC libraries
DLL_LOCAL extern char* knc_library_path;

// LD_LIBRARY_PATH for KNL libraries
DLL_LOCAL extern char* knl_library_path;

// stack size for target
DLL_LOCAL extern uint32_t mic_stack_size;

// Preallocated memory size for buffers on MIC
DLL_LOCAL extern uint64_t mic_buffer_size;

// Preallocated 4K page memory size for buffers on MIC
DLL_LOCAL extern uint64_t mic_4k_buffer_size;

// Preallocated 2M page memory size for buffers on MIC
DLL_LOCAL extern uint64_t mic_2m_buffer_size;

// Setting controlling inout proxy
DLL_LOCAL extern bool  mic_proxy_io;
DLL_LOCAL extern char* mic_proxy_fs_root;

// Threshold for creating buffers with large pages
DLL_LOCAL extern uint64_t __offload_use_2mb_buffers;

// offload initialization type
DLL_LOCAL extern OffloadInitType __offload_init_type;

// Device number to offload to when device is not explicitly specified.
DLL_LOCAL extern int __omp_device_num;

// target executable
DLL_LOCAL extern TargetImage* __target_exe;

// is true if last loaded image is dll
DLL_LOCAL extern bool __current_image_is_dll;
// is true if myo library is loaded when dll is loaded
DLL_LOCAL extern bool __myo_init_in_so;

// IDB support

// Called by the offload runtime after initialization of offload infrastructure
// has been completed.
extern "C" void  __dbg_target_so_loaded();

// Called by the offload runtime when the offload infrastructure is about to be
// shut down, currently at application exit.
extern "C" void  __dbg_target_so_unloaded();

// Null-terminated string containing path to the process image of the hosting
// application (offload_main)
#define MAX_TARGET_NAME 512
extern "C" char  __dbg_target_exe_name[MAX_TARGET_NAME];

// Integer specifying the process id
extern "C" pid_t __dbg_target_so_pid;

// Integer specifying the 0-based device number
extern "C" int   __dbg_target_id;

// Set to non-zero by the host-side debugger to enable offload debugging
// support
extern "C" int   __dbg_is_attached;

// Major version of the debugger support API
extern "C" const int __dbg_api_major_version;

// Minor version of the debugger support API
extern "C" const int __dbg_api_minor_version;

#endif // OFFLOAD_HOST_H_INCLUDED