diff options
Diffstat (limited to 'openmp/offload/src/offload_omp_target.cpp')
| -rw-r--r-- | openmp/offload/src/offload_omp_target.cpp | 1021 |
1 files changed, 1021 insertions, 0 deletions
diff --git a/openmp/offload/src/offload_omp_target.cpp b/openmp/offload/src/offload_omp_target.cpp new file mode 100644 index 00000000000..1f2052a9dad --- /dev/null +++ b/openmp/offload/src/offload_omp_target.cpp @@ -0,0 +1,1021 @@ +//===----------------------------------------------------------------------===// +// +// 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 <omp.h> +#include "offload.h" +#include "compiler_if_target.h" + +// OpenMP API + +void omp_set_default_device(int num) +{ +} + +int omp_get_default_device(void) +{ + return mic_index; +} + +int omp_get_num_devices() +{ + return mic_engines_total; +} + +// OpenMP API wrappers + +static void omp_send_int_to_host( + void *ofld_, + int setting +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_out; + vars[0].ptr = &setting; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + OFFLOAD_TARGET_LEAVE(ofld); +} + +static int omp_get_int_from_host( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + int setting; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &setting; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + OFFLOAD_TARGET_LEAVE(ofld); + + return setting; +} + +void omp_set_num_threads_lrb( + void *ofld +) +{ + int num_threads; + + num_threads = omp_get_int_from_host(ofld); + omp_set_num_threads(num_threads); +} + +void omp_get_max_threads_lrb( + void *ofld +) +{ + int num_threads; + + num_threads = omp_get_max_threads(); + omp_send_int_to_host(ofld, num_threads); +} + +void omp_get_num_procs_lrb( + void *ofld +) +{ + int num_procs; + + num_procs = omp_get_num_procs(); + omp_send_int_to_host(ofld, num_procs); +} + +void omp_set_dynamic_lrb( + void *ofld +) +{ + int dynamic; + + dynamic = omp_get_int_from_host(ofld); + omp_set_dynamic(dynamic); +} + +void omp_get_dynamic_lrb( + void *ofld +) +{ + int dynamic; + + dynamic = omp_get_dynamic(); + omp_send_int_to_host(ofld, dynamic); +} + +void omp_set_nested_lrb( + void *ofld +) +{ + int nested; + + nested = omp_get_int_from_host(ofld); + omp_set_nested(nested); +} + +void omp_get_nested_lrb( + void *ofld +) +{ + int nested; + + nested = omp_get_nested(); + omp_send_int_to_host(ofld, nested); +} + +void omp_set_schedule_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[2] = {0}; + omp_sched_t kind; + int modifier; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &kind; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_in; + vars[1].ptr = &modifier; + + OFFLOAD_TARGET_ENTER(ofld, 2, vars, NULL); + omp_set_schedule(kind, modifier); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_get_schedule_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[2] = {0}; + omp_sched_t kind; + int modifier; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_out; + vars[0].ptr = &kind; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_out; + vars[1].ptr = &modifier; + + OFFLOAD_TARGET_ENTER(ofld, 2, vars, NULL); + omp_get_schedule(&kind, &modifier); + OFFLOAD_TARGET_LEAVE(ofld); +} + +// lock API functions + +void omp_init_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_out; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_init_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_destroy_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_destroy_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_set_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_set_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_unset_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_unset_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_test_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[2] = {0}; + omp_lock_target_t lock; + int result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &lock; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_out; + vars[1].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 2, vars, NULL); + result = omp_test_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +// nested lock API functions + +void omp_init_nest_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_nest_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_out; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_init_nest_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_destroy_nest_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_nest_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_destroy_nest_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_set_nest_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_nest_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_set_nest_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_unset_nest_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + omp_nest_lock_target_t lock; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &lock; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + omp_unset_nest_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void omp_test_nest_lock_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[2] = {0}; + omp_nest_lock_target_t lock; + int result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &lock; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_out; + vars[1].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 2, vars, NULL); + result = omp_test_nest_lock(&lock.lock); + OFFLOAD_TARGET_LEAVE(ofld); +} + +// kmp API functions + +void kmp_set_stacksize_lrb( + void *ofld +) +{ + int size; + + size = omp_get_int_from_host(ofld); + kmp_set_stacksize(size); +} + +void kmp_get_stacksize_lrb( + void *ofld +) +{ + int size; + + size = kmp_get_stacksize(); + omp_send_int_to_host(ofld, size); +} + +void kmp_set_stacksize_s_lrb( + void *ofld +) +{ + int size; + + size = omp_get_int_from_host(ofld); + kmp_set_stacksize_s(size); +} + +void kmp_get_stacksize_s_lrb( + void *ofld +) +{ + int size; + + size = kmp_get_stacksize_s(); + omp_send_int_to_host(ofld, size); +} + +void kmp_set_blocktime_lrb( + void *ofld +) +{ + int time; + + time = omp_get_int_from_host(ofld); + kmp_set_blocktime(time); +} + +void kmp_get_blocktime_lrb( + void *ofld +) +{ + int time; + + time = kmp_get_blocktime(); + omp_send_int_to_host(ofld, time); +} + +void kmp_set_library_serial_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + + OFFLOAD_TARGET_ENTER(ofld, 0, 0, 0); + kmp_set_library_serial(); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_set_library_turnaround_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + + OFFLOAD_TARGET_ENTER(ofld, 0, 0, 0); + kmp_set_library_turnaround(); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_set_library_throughput_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + + OFFLOAD_TARGET_ENTER(ofld, 0, 0, 0); + kmp_set_library_throughput(); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_set_library_lrb( + void *ofld +) +{ + int mode; + + mode = omp_get_int_from_host(ofld); + kmp_set_library(mode); +} + +void kmp_get_library_lrb( + void *ofld +) +{ + int mode; + + mode = kmp_get_library(); + omp_send_int_to_host(ofld, mode); +} + +void kmp_set_defaults_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + char *defaults = 0; + + vars[0].type.src = c_string_ptr; + vars[0].type.dst = c_string_ptr; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &defaults; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + kmp_set_defaults(defaults); + OFFLOAD_TARGET_LEAVE(ofld); +} + +// affinity API functions + +void kmp_create_affinity_mask_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + kmp_affinity_mask_target_t mask; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_out; + vars[0].ptr = &mask; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + kmp_create_affinity_mask(&mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_destroy_affinity_mask_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[1] = {0}; + kmp_affinity_mask_target_t mask; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &mask; + + OFFLOAD_TARGET_ENTER(ofld, 1, vars, NULL); + kmp_destroy_affinity_mask(&mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_set_affinity_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[2] = {0}; + kmp_affinity_mask_target_t mask; + int result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &mask; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_out; + vars[1].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 2, vars, NULL); + result = kmp_set_affinity(&mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_get_affinity_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[2] = {0}; + kmp_affinity_mask_target_t mask; + int result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_inout; + vars[0].ptr = &mask; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_out; + vars[1].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 2, vars, NULL); + result = kmp_get_affinity(&mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_get_affinity_max_proc_lrb( + void *ofld +) +{ + int max_proc; + + max_proc = kmp_get_affinity_max_proc(); + omp_send_int_to_host(ofld, max_proc); +} + +void kmp_set_affinity_mask_proc_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[3] = {0}; + kmp_affinity_mask_target_t mask; + int proc, result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &proc; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_inout; + vars[1].ptr = &mask; + + vars[2].type.src = c_data; + vars[2].type.dst = c_data; + vars[2].direction.bits = c_parameter_out; + vars[2].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 3, vars, NULL); + result = kmp_set_affinity_mask_proc(proc, &mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_unset_affinity_mask_proc_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[3] = {0}; + kmp_affinity_mask_target_t mask; + int proc, result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &proc; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_inout; + vars[1].ptr = &mask; + + vars[2].type.src = c_data; + vars[2].type.dst = c_data; + vars[2].direction.bits = c_parameter_out; + vars[2].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 3, vars, NULL); + result = kmp_unset_affinity_mask_proc(proc, &mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +void kmp_get_affinity_mask_proc_lrb( + void *ofld_ +) +{ + OFFLOAD ofld = (OFFLOAD) ofld_; + VarDesc vars[3] = {0}; + kmp_affinity_mask_target_t mask; + int proc, result; + + vars[0].type.src = c_data; + vars[0].type.dst = c_data; + vars[0].direction.bits = c_parameter_in; + vars[0].ptr = &proc; + + vars[1].type.src = c_data; + vars[1].type.dst = c_data; + vars[1].direction.bits = c_parameter_in; + vars[1].ptr = &mask; + + vars[2].type.src = c_data; + vars[2].type.dst = c_data; + vars[2].direction.bits = c_parameter_out; + vars[2].ptr = &result; + + OFFLOAD_TARGET_ENTER(ofld, 3, vars, NULL); + result = kmp_get_affinity_mask_proc(proc, &mask.mask); + OFFLOAD_TARGET_LEAVE(ofld); +} + +// Target-side stubs for the host functions (to avoid unresolveds) +// These are needed for the offloadm table + +void omp_set_num_threads_target( + TARGET_TYPE target_type, + int target_number, + int num_threads +) +{ +} + +int omp_get_max_threads_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +int omp_get_num_procs_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void omp_set_dynamic_target( + TARGET_TYPE target_type, + int target_number, + int num_threads +) +{ +} + +int omp_get_dynamic_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void omp_set_nested_target( + TARGET_TYPE target_type, + int target_number, + int num_threads +) +{ +} + +int omp_get_nested_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void omp_set_schedule_target( + TARGET_TYPE target_type, + int target_number, + omp_sched_t kind, + int modifier +) +{ +} + +void omp_get_schedule_target( + TARGET_TYPE target_type, + int target_number, + omp_sched_t *kind, + int *modifier +) +{ +} + +void omp_init_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_lock_target_t *lock +) +{ +} + +void omp_destroy_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_lock_target_t *lock +) +{ +} + +void omp_set_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_lock_target_t *lock +) +{ +} + +void omp_unset_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_lock_target_t *lock +) +{ +} + +int omp_test_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_lock_target_t *lock +) +{ + return 0; +} + +void omp_init_nest_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_nest_lock_target_t *lock +) +{ +} + +void omp_destroy_nest_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_nest_lock_target_t *lock +) +{ +} + +void omp_set_nest_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_nest_lock_target_t *lock +) +{ +} + +void omp_unset_nest_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_nest_lock_target_t *lock +) +{ +} + +int omp_test_nest_lock_target( + TARGET_TYPE target_type, + int target_number, + omp_nest_lock_target_t *lock +) +{ + return 0; +} + +void kmp_set_stacksize_target( + TARGET_TYPE target_type, + int target_number, + int size +) +{ +} + +int kmp_get_stacksize_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void kmp_set_stacksize_s_target( + TARGET_TYPE target_type, + int target_number, + size_t size +) +{ +} + +size_t kmp_get_stacksize_s_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void kmp_set_blocktime_target( + TARGET_TYPE target_type, + int target_number, + int time +) +{ +} + +int kmp_get_blocktime_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void kmp_set_library_serial_target( + TARGET_TYPE target_type, + int target_number +) +{ +} + +void kmp_set_library_turnaround_target( + TARGET_TYPE target_type, + int target_number +) +{ +} + +void kmp_set_library_throughput_target( + TARGET_TYPE target_type, + int target_number +) +{ +} + +void kmp_set_library_target( + TARGET_TYPE target_type, + int target_number, + int mode +) +{ +} + +int kmp_get_library_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +void kmp_set_defaults_target( + TARGET_TYPE target_type, + int target_number, + char const *defaults +) +{ +} + +void kmp_create_affinity_mask_target( + TARGET_TYPE target_type, + int target_number, + kmp_affinity_mask_target_t *mask +) +{ +} + +void kmp_destroy_affinity_mask_target( + TARGET_TYPE target_type, + int target_number, + kmp_affinity_mask_target_t *mask +) +{ +} + +int kmp_set_affinity_target( + TARGET_TYPE target_type, + int target_number, + kmp_affinity_mask_target_t *mask +) +{ + return 0; +} + +int kmp_get_affinity_target( + TARGET_TYPE target_type, + int target_number, + kmp_affinity_mask_target_t *mask +) +{ + return 0; +} + +int kmp_get_affinity_max_proc_target( + TARGET_TYPE target_type, + int target_number +) +{ + return 0; +} + +int kmp_set_affinity_mask_proc_target( + TARGET_TYPE target_type, + int target_number, + int proc, + kmp_affinity_mask_target_t *mask +) +{ + return 0; +} + +int kmp_unset_affinity_mask_proc_target( + TARGET_TYPE target_type, + int target_number, + int proc, + kmp_affinity_mask_target_t *mask +) +{ + return 0; +} + +int kmp_get_affinity_mask_proc_target( + TARGET_TYPE target_type, + int target_number, + int proc, + kmp_affinity_mask_target_t *mask +) +{ + return 0; +} |
