final/offload/src/offload_omp_target.cpp

//===----------------------------------------------------------------------===//
//
//                     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;
}