mirror of git://gcc.gnu.org/git/gcc.git
542 lines
17 KiB
C++
542 lines
17 KiB
C++
/*
|
|
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
|