diff options
Diffstat (limited to 'liboffloadmic/runtime/compiler_if_host.cpp')
| -rw-r--r-- | liboffloadmic/runtime/compiler_if_host.cpp | 170 |
1 files changed, 161 insertions, 9 deletions
diff --git a/liboffloadmic/runtime/compiler_if_host.cpp b/liboffloadmic/runtime/compiler_if_host.cpp index c4e2a15633f..7bac0e54de8 100644 --- a/liboffloadmic/runtime/compiler_if_host.cpp +++ b/liboffloadmic/runtime/compiler_if_host.cpp @@ -1,5 +1,5 @@ /* - Copyright (c) 2014 Intel Corporation. All Rights Reserved. + Copyright (c) 2014-2015 Intel Corporation. All Rights Reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions @@ -35,7 +35,7 @@ #include <alloca.h> #endif // TARGET_WINNT -// Global counter on host. +// Global counter on host. // This variable is used if P2OPT_offload_do_data_persistence == 2. // The variable used to identify offload constructs contained in one procedure. // Increment of OFFLOAD_CALL_COUNT is inserted at entries of HOST routines with @@ -72,7 +72,7 @@ extern "C" OFFLOAD OFFLOAD_TARGET_ACQUIRE( OFFLOAD_TIMER_START(timer_data, c_offload_host_initialize); - // initalize all devices is init_type is on_offload_all + // initialize all devices is init_type is on_offload_all if (retval && __offload_init_type == c_init_on_offload_all) { for (int i = 0; i < mic_engines_total; i++) { mic_engines[i].init(); @@ -241,7 +241,128 @@ extern "C" OFFLOAD OFFLOAD_TARGET_ACQUIRE1( return ofld; } -int offload_offload_wrap( +extern "C" OFFLOAD OFFLOAD_TARGET_ACQUIRE2( + TARGET_TYPE target_type, + int target_number, + int is_optional, + _Offload_status* status, + const char* file, + uint64_t line, + const void** stream +) +{ + bool retval; + OFFLOAD ofld; + + // initialize status + if (status != 0) { + status->result = OFFLOAD_UNAVAILABLE; + status->device_number = -1; + status->data_sent = 0; + status->data_received = 0; + } + + // make sure libray is initialized + retval = __offload_init_library(); + // OFFLOAD_TIMER_INIT must follow call to __offload_init_library + OffloadHostTimerData * timer_data = OFFLOAD_TIMER_INIT(file, line); + + OFFLOAD_TIMER_START(timer_data, c_offload_host_total_offload); + + OFFLOAD_TIMER_START(timer_data, c_offload_host_initialize); + + // initalize all devices if init_type is on_offload_all + if (retval && __offload_init_type == c_init_on_offload_all) { + for (int i = 0; i < mic_engines_total; i++) { + mic_engines[i].init(); + } + } + OFFLOAD_TIMER_STOP(timer_data, c_offload_host_initialize); + + OFFLOAD_TIMER_START(timer_data, c_offload_host_target_acquire); + + if (target_type == TARGET_HOST) { + // Host always available + retval = true; + } + else if (target_type == TARGET_MIC) { + _Offload_stream handle = *(reinterpret_cast<_Offload_stream*>(stream)); + Stream * stream = handle ? Stream::find_stream(handle, false) : NULL; + if (target_number >= -1) { + if (retval) { + // device number is defined by stream + if (stream) { + target_number = stream->get_device(); + target_number = target_number % mic_engines_total; + } + + // reserve device in ORSL + if (target_number != -1) { + if (is_optional) { + if (!ORSL::try_reserve(target_number)) { + target_number = -1; + } + } + else { + if (!ORSL::reserve(target_number)) { + target_number = -1; + } + } + } + + // initialize device + if (target_number >= 0 && + __offload_init_type == c_init_on_offload) { + OFFLOAD_TIMER_START(timer_data, c_offload_host_initialize); + mic_engines[target_number].init(); + OFFLOAD_TIMER_STOP(timer_data, c_offload_host_initialize); + } + } + else { + // fallback to CPU + target_number = -1; + } + if (!(target_number == -1 && handle == 0)) { + if (target_number < 0 || !retval) { + if (!is_optional && status == 0) { + LIBOFFLOAD_ERROR(c_device_is_not_available); + exit(1); + } + + retval = false; + } + } + } + else { + LIBOFFLOAD_ERROR(c_invalid_device_number); + exit(1); + } + } + + if (retval) { + ofld = new OffloadDescriptor(target_number, status, + !is_optional, false, timer_data); + OFFLOAD_TIMER_HOST_MIC_NUM(timer_data, target_number); + Offload_Report_Prolog(timer_data); + OFFLOAD_DEBUG_TRACE_1(2, timer_data->offload_number, c_offload_start, + "Starting offload: target_type = %d, " + "number = %d, is_optional = %d\n", + target_type, target_number, is_optional); + + OFFLOAD_TIMER_STOP(timer_data, c_offload_host_target_acquire); + } + else { + ofld = NULL; + + OFFLOAD_TIMER_STOP(timer_data, c_offload_host_target_acquire); + OFFLOAD_TIMER_STOP(timer_data, c_offload_host_total_offload); + offload_report_free_data(timer_data); + } + + return ofld; +} + +static int offload_offload_wrap( OFFLOAD ofld, const char *name, int is_empty, @@ -252,12 +373,15 @@ int offload_offload_wrap( const void **waits, const void **signal, int entry_id, - const void *stack_addr + const void *stack_addr, + OffloadFlags offload_flags ) { bool ret = ofld->offload(name, is_empty, vars, vars2, num_vars, - waits, num_waits, signal, entry_id, stack_addr); - if (!ret || signal == 0) { + waits, num_waits, signal, entry_id, + stack_addr, offload_flags); + if (!ret || (signal == 0 && ofld->get_stream() == 0 && + !offload_flags.bits.omp_async)) { delete ofld; } return ret; @@ -278,7 +402,7 @@ extern "C" int OFFLOAD_OFFLOAD1( return offload_offload_wrap(ofld, name, is_empty, num_vars, vars, vars2, num_waits, waits, - signal, NULL, NULL); + signal, 0, NULL, {0}); } extern "C" int OFFLOAD_OFFLOAD2( @@ -298,7 +422,35 @@ extern "C" int OFFLOAD_OFFLOAD2( return offload_offload_wrap(ofld, name, is_empty, num_vars, vars, vars2, num_waits, waits, - signal, entry_id, stack_addr); + signal, entry_id, stack_addr, {0}); +} + +extern "C" int OFFLOAD_OFFLOAD3( + OFFLOAD ofld, + const char *name, + int is_empty, + int num_vars, + VarDesc *vars, + VarDesc2 *vars2, + int num_waits, + const void** waits, + const void** signal, + int entry_id, + const void *stack_addr, + OffloadFlags offload_flags, + const void** stream +) +{ + // 1. if the source is compiled with -traceback then stream is 0 + // 2. if offload has a stream clause then stream is address of stream value + if (stream) { + ofld->set_stream(*(reinterpret_cast<_Offload_stream *>(stream))); + } + + return offload_offload_wrap(ofld, name, is_empty, + num_vars, vars, vars2, + num_waits, waits, + signal, entry_id, stack_addr, offload_flags); } extern "C" int OFFLOAD_OFFLOAD( |