Macintosh-Tools/Retro68
1
0
Fork 0
mirror of https://github.com/autc04/Retro68.git synced 2024-11-29 12:50:35 +00:00
Code Issues Projects Releases Wiki Activity
413bb90073
Retro68/gcc/liboffloadmic/runtime/offload_omp_host.cpp

1268 lines
39 KiB
C++
Raw Normal View History

Update gcc to 5.2.0
2015-08-28 15:33:40 +00:00
/*
Update gcc to 7.2.0, binutils to 2.29, newlib to 2.5.0
2017-10-07 00:16:47 +00:00
Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
Update gcc to 5.2.0
2015-08-28 15:33:40 +00:00
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.
*/
#include <omp.h>
Update gcc to 7.2.0, binutils to 2.29, newlib to 2.5.0
2017-10-07 00:16:47 +00:00
//#include <stdlib.h>
//#include "offload.h"
Update gcc to 5.2.0
2015-08-28 15:33:40 +00:00
#include "compiler_if_host.h"
Update gcc to 7.2.0, binutils to 2.29, newlib to 2.5.0
2017-10-07 00:16:47 +00:00
Update gcc to 5.2.0
2015-08-28 15:33:40 +00:00
// OpenMP API
void omp_set_default_device(int num) __GOMP_NOTHROW
{
if (num >= 0) {
__omp_device_num = num;
}
}
int omp_get_default_device(void) __GOMP_NOTHROW
{
return __omp_device_num;
}
int omp_get_num_devices() __GOMP_NOTHROW
{
__offload_init_library();
return mic_engines_total;
}
Update gcc to 7.2.0, binutils to 2.29, newlib to 2.5.0
2017-10-07 00:16:47 +00:00
// OpenMP 4.5 APIs
// COI supports 3-dim multiD transfers
#define MAX_ARRAY_RANK 3
int omp_get_initial_device(
void
) __GOMP_NOTHROW
{
return -1;
}
void* omp_target_alloc(
size_t size,
int device_num
) __GOMP_NOTHROW
{
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_alloc(%lld, %d)\n", size, device_num);
if (device_num < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
void* result = 0;
// malloc on CPU
if (device_num == -1) {
// We do not check for malloc returning NULL because the
// specification of this API includes the possibility of failure.
// The user will check the returned result
result = malloc(size);
return result;
}
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(
TARGET_MIC, device_num, 0, NULL, __func__, 0);
if (ofld != 0) {
VarDesc vars[2] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(size);
vars[0].count = 1;
vars[0].ptr = &size;
vars[1].type.src = c_data;
vars[1].type.dst = c_data;
vars[1].direction.bits = c_parameter_out;
vars[1].size = sizeof(result);
vars[1].count = 1;
vars[1].ptr = &result;
OFFLOAD_OFFLOAD(ofld, "omp_target_alloc_target",
0, 2, vars, NULL, 0, 0, 0);
}
return result;
}
void omp_target_free(
void *device_ptr,
int device_num
) __GOMP_NOTHROW
{
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_free(%p, %d)\n", device_ptr, device_num);
if (device_num < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
// free on CPU
if (device_num == -1) {
free(device_ptr);
return;
}
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(
TARGET_MIC, device_num, 0, NULL, __func__, 0);
if (ofld) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(device_ptr);
vars[0].count = 1;
vars[0].ptr = &device_ptr;
OFFLOAD_OFFLOAD(ofld, "omp_target_free_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
int omp_target_is_present(
void *ptr,
int device_num
) __GOMP_NOTHROW
{
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_is_present(%p, %d)\n", ptr, device_num);
if (device_num < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
if (device_num == -1) {
return false;
}
// If OpenMP allows wrap-around for device numbers, enable next line
//device_num %= mic_engines_total;
// lookup existing association in pointer table
PtrData* ptr_data = mic_engines[device_num].find_ptr_data(ptr);
if (ptr_data == 0) {
OFFLOAD_TRACE(3, "Address %p is not mapped on device %d\n",
ptr, device_num);
return false;
}
OFFLOAD_TRACE(3, "Address %p found mapped on device %d\n",
ptr, device_num);
return true;
}
int omp_target_memcpy(
void *dst,
void *src,
size_t length,
size_t dst_offset,
size_t src_offset,
int dst_device,
int src_device
) __GOMP_NOTHROW
{
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_memcpy(%p, %p, %lld, %lld, %lld, %d, %d)\n",
dst, src, length, dst_offset, src_offset, dst_device, src_device);
if (dst_device < -1 || src_device < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
char* srcp = (char *)src + src_offset;
char* dstp = (char *)dst + dst_offset;
if (src_device == -1) {
// Source is CPU
if (dst_device == -1) {
// CPU -> CPU
memcpy(dstp, srcp, length);
return 0;
} else {
// CPU -> MIC
// COIBufferWrite
// If OpenMP allows wrap-around for device numbers, enable next line
//dst_device %= mic_engines_total;
OFFLOAD_TRACE(3, "Creating buffer from sink memory %llx\n", dstp);
COIBUFFER mic_buf;
COIRESULT res = COI::BufferCreateFromMemory(length,
COI_BUFFER_NORMAL, COI_SINK_MEMORY, dstp,
1, &mic_engines[dst_device].get_process(),
&mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
return 1;
}
res = COI::BufferWrite(mic_buf, 0, srcp, length,
COI_COPY_UNSPECIFIED, 0, 0, 0);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_write, res);
return 1;
}
res = COI::BufferDestroy(mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_destroy, res);
return 1;
}
return 0;
}
} else {
// Source is device
if (dst_device == -1) {
// MIC -> CPU
// COIBufferRead
// If OpenMP allows wrap-around for device numbers, enable next line
//src_device %= mic_engines_total;
OFFLOAD_TRACE(3, "Creating buffer from sink memory %llx\n", srcp);
COIBUFFER mic_buf;
COIRESULT res = COI::BufferCreateFromMemory(length,
COI_BUFFER_NORMAL, COI_SINK_MEMORY, srcp,
1, &mic_engines[src_device].get_process(),
&mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
return 1;
}
res = COI::BufferRead(mic_buf, 0, dstp, length,
COI_COPY_UNSPECIFIED, 0, 0, 0);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_read, res);
return 1;
}
res = COI::BufferDestroy(mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_destroy, res);
return 1;
}
return 0;
} else {
// some MIC -> some MIC
if (src_device == dst_device) {
// MIC local copy will be done as remote memcpy
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(TARGET_MIC, src_device,
0, NULL, __func__, 0);
if (ofld) {
VarDesc vars[3] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(dstp);
vars[0].count = 1;
vars[0].ptr = &dstp;
vars[1].type.src = c_data;
vars[1].type.dst = c_data;
vars[1].direction.bits = c_parameter_in;
vars[1].size = sizeof(srcp);
vars[1].count = 1;
vars[1].ptr = &srcp;
vars[2].type.src = c_data;
vars[2].type.dst = c_data;
vars[2].direction.bits = c_parameter_in;
vars[2].size = sizeof(length);
vars[2].count = 1;
vars[2].ptr = &length;
OFFLOAD_OFFLOAD(ofld, "omp_target_memcpy_target",
0, 3, vars, NULL, 0, 0, 0);
return 0;
} else {
return 1;
}
} else {
// MICx -> MICy
// Allocate CPU buffer
char *cpu_mem = (char *)malloc(length);
if (cpu_mem == 0) {
LIBOFFLOAD_ERROR(c_malloc);
return 1;
}
int retval = 1;
if (omp_target_memcpy(
cpu_mem, srcp, length, 0, 0, -1, src_device) == 0) {
retval = omp_target_memcpy(
dstp, cpu_mem, length, 0, 0, dst_device, -1);
}
free(cpu_mem);
return retval;
}
}
}
}
static size_t bytesize_at_this_dimension(
size_t element_size,
int num_dims,
const size_t* dimensions
)
{
if (num_dims > 1) {
return dimensions[1] *
bytesize_at_this_dimension(
element_size, num_dims-1, dimensions+1);
} else {
return element_size;
}
}
static void memcpy_rect(
char *dst,
char *src,
size_t element_size,
int num_dims,
const size_t *volume,
const size_t *dst_offsets,
const size_t *src_offsets,
const size_t *dst_dimensions,
const size_t *src_dimensions
)
{
if (num_dims > 1) {
int count = volume[0];
int dst_index = dst_offsets[0];
int src_index = src_offsets[0];
size_t dst_element_size =
bytesize_at_this_dimension(element_size, num_dims, dst_dimensions);
size_t src_element_size =
bytesize_at_this_dimension(element_size, num_dims, src_dimensions);
for (; count>0; dst_index++, src_index++, count--) {
memcpy_rect(dst+dst_element_size*dst_index,
src+src_element_size*src_index,
element_size, num_dims-1, volume+1,
dst_offsets+1, src_offsets+1,
dst_dimensions+1, src_dimensions+1);
}
} else {
memcpy(dst+dst_offsets[0]*element_size,
src+src_offsets[0]*element_size,
element_size * volume[0]);
}
}
int omp_target_memcpy_rect(
void *dst_,
void *src_,
size_t element_size,
int num_dims,
const size_t *volume,
const size_t *dst_offsets,
const size_t *src_offsets,
const size_t *dst_dimensions,
const size_t *src_dimensions,
int dst_device,
int src_device
) __GOMP_NOTHROW
{
char *dst = (char *)dst_;
char *src = (char *)src_;
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_memcpy_rect(%p, %p, %lld, %d, "
"%p, %p, %p, %p, %p, %d, %d)\n",
dst, src, element_size, num_dims,
volume, dst_offsets, src_offsets,
dst_dimensions, src_dimensions, dst_device, src_device);
// MAX_ARRAY_RANK dimensions are supported
if (dst == 0 && src == 0) {
return MAX_ARRAY_RANK;
}
if (num_dims < 1 || num_dims > MAX_ARRAY_RANK ||
element_size < 1 ||
volume == 0 || dst_offsets == 0 || src_offsets == 0 ||
dst_dimensions == 0 || src_dimensions == 0) {
return 1;
}
if (dst_device < -1 || src_device < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
if (src_device == -1) {
// Source is CPU
if (dst_device == -1) {
// CPU -> CPU
memcpy_rect((char*)dst, (char*)src, element_size, num_dims, volume,
dst_offsets, src_offsets,
dst_dimensions, src_dimensions);
return 0;
} else {
// CPU -> MIC
// COIBufferWriteMultiD
struct arr_desc dst_desc;
struct arr_desc src_desc;
dst_desc.base = (int64_t)dst;
dst_desc.rank = num_dims;
src_desc.base = (int64_t)src;
src_desc.rank = num_dims;
for (int i=0; i<num_dims; i++)
{
dst_desc.dim[i].size = bytesize_at_this_dimension(
element_size,
num_dims - i,
dst_dimensions + i);
dst_desc.dim[i].lindex = 0;
dst_desc.dim[i].lower = dst_offsets[i];
dst_desc.dim[i].upper = dst_offsets[i] + volume[i] - 1;
dst_desc.dim[i].stride = 1;
src_desc.dim[i].size = bytesize_at_this_dimension(
element_size,
num_dims - i,
src_dimensions + i);
src_desc.dim[i].lindex = 0;
src_desc.dim[i].lower = src_offsets[i];
src_desc.dim[i].upper = src_offsets[i] + volume[i] - 1;
src_desc.dim[i].stride = 1;
}
__arr_desc_dump("", "dst", (const Arr_Desc*)&dst_desc, false, false);
__arr_desc_dump("", "src", (const Arr_Desc*)&src_desc, false, false);
// If OpenMP allows wrap-around for device numbers, enable next line
//dst_device %= mic_engines_total;
// Compute MIC buffer size
size_t dst_length = dst_dimensions[0] * bytesize_at_this_dimension(
element_size,
num_dims,
dst_dimensions);
OFFLOAD_TRACE(3,
"Creating buffer from sink memory %llx of size %lld\n",
dst, dst_length);
COIBUFFER mic_buf;
COIRESULT res = COI::BufferCreateFromMemory(dst_length,
COI_BUFFER_NORMAL, COI_SINK_MEMORY, dst,
1, &mic_engines[dst_device].get_process(),
&mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
return 1;
}
res = COI::BufferWriteMultiD(mic_buf,
mic_engines[dst_device].get_process(),
0, &dst_desc, &src_desc,
COI_COPY_UNSPECIFIED, 0, 0, 0);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_write, res);
return 1;
}
res = COI::BufferDestroy(mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_destroy, res);
return 1;
}
return 0;
}
} else {
// Source is device
if (dst_device == -1) {
// COIBufferReadMultiD
struct arr_desc dst_desc;
struct arr_desc src_desc;
dst_desc.base = (int64_t)dst;
dst_desc.rank = num_dims;
src_desc.base = (int64_t)src;
src_desc.rank = num_dims;
for (int i=0; i<num_dims; i++)
{
dst_desc.dim[i].size = bytesize_at_this_dimension(
element_size,
num_dims - i,
dst_dimensions + i);
dst_desc.dim[i].lindex = 0;
dst_desc.dim[i].lower = dst_offsets[i];
dst_desc.dim[i].upper = dst_offsets[i] + volume[i] - 1;
dst_desc.dim[i].stride = 1;
src_desc.dim[i].size = bytesize_at_this_dimension(
element_size,
num_dims - i,
src_dimensions + i);
src_desc.dim[i].lindex = 0;
src_desc.dim[i].lower = src_offsets[i];
src_desc.dim[i].upper = src_offsets[i] + volume[i] - 1;
src_desc.dim[i].stride = 1;
}
__arr_desc_dump("", "dst", (const Arr_Desc*)&dst_desc, false, false);
__arr_desc_dump("", "src", (const Arr_Desc*)&src_desc, false, false);
// If OpenMP allows wrap-around for device numbers, enable next line
//src_device %= mic_engines_total;
// Compute MIC buffer size
size_t src_length = src_dimensions[0] * bytesize_at_this_dimension(
element_size,
num_dims,
src_dimensions);
OFFLOAD_TRACE(3,
"Creating buffer from sink memory %llx of size %lld\n",
src, src_length);
COIBUFFER mic_buf;
COIRESULT res = COI::BufferCreateFromMemory(src_length,
COI_BUFFER_NORMAL, COI_SINK_MEMORY, src,
1, &mic_engines[src_device].get_process(),
&mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
return 1;
}
res = COI::BufferReadMultiD(mic_buf, 0,
&dst_desc, &src_desc,
COI_COPY_UNSPECIFIED, 0, 0, 0);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_write, res);
return 1;
}
res = COI::BufferDestroy(mic_buf);
if (res != COI_SUCCESS) {
LIBOFFLOAD_ERROR(c_buf_destroy, res);
return 1;
}
return 0;
} else {
// some MIC -> some MIC
if (src_device == dst_device) {
// MIC local copy will be done as remote memcpy_rect
struct parameters {
void *dst;
void *src;
size_t element_size;
int num_dims;
size_t array_info[MAX_ARRAY_RANK*5];
} parameters = {dst, src, element_size, num_dims};
int result;
for (int i=0; i<num_dims; i++)
{
parameters.array_info[i] = volume[i];
parameters.array_info[i+num_dims] = dst_offsets[i];
parameters.array_info[i+num_dims*2] = src_offsets[i];
parameters.array_info[i+num_dims*3] = dst_dimensions[i];
parameters.array_info[i+num_dims*4] = src_dimensions[i];
}
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(TARGET_MIC, src_device,
0, NULL, __func__, 0);
if (ofld) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(parameters) -
(MAX_ARRAY_RANK - num_dims) *
5 * sizeof(size_t);
vars[0].count = 1;
vars[0].ptr = &parameters;
OFFLOAD_OFFLOAD(ofld, "omp_target_memcpy_rect_target",
0, 1, vars, NULL, 0, 0, 0);
return 0;
} else {
return 1;
}
} else {
// MICx -> MICy
// Compute transfer byte-count
size_t dst_length = element_size;
for (int i=0; i<num_dims; i++) {
dst_length *= volume[i];
}
// Allocate CPU buffer
char *cpu_mem = (char *)malloc(dst_length);
if (cpu_mem == 0) {
LIBOFFLOAD_ERROR(c_malloc);
return 1;
}
// Create CPU offset and dimension arrays
// The CPU array collects the data in a contiguous block
size_t cpu_offsets[MAX_ARRAY_RANK];
size_t cpu_dimensions[MAX_ARRAY_RANK];
for (int i=0; i<num_dims; i++) {
cpu_offsets[i] = 0;
cpu_dimensions[i] = volume[i];
}
int retval = 1;
if (omp_target_memcpy_rect(
cpu_mem, src, element_size, num_dims, volume,
cpu_offsets, src_offsets,
cpu_dimensions, src_dimensions,
-1, src_device) == 0) {
retval = omp_target_memcpy_rect(
dst, cpu_mem, element_size, num_dims, volume,
dst_offsets, cpu_offsets,
dst_dimensions, cpu_dimensions,
dst_device, -1);
}
free(cpu_mem);
return retval;
}
}
}
}
// host_ptr is key in table that yields association on device
// A COIBUFFER of specified size is created from the memory at
// device_ptr+device_offset on device_num
int omp_target_associate_ptr(
void *host_ptr,
void *device_ptr,
size_t size,
size_t device_offset,
int device_num
) __GOMP_NOTHROW
{
COIRESULT res;
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_associate_ptr(%p, %p, %lld, %lld, %d)\n",
host_ptr, device_ptr, size, device_offset, device_num);
if (device_num < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
// Associating to CPU is treated as failure
if (device_num == -1) {
return 1;
}
// An incorrect size is treated as failure
if (size < 0) {
return 1;
}
// If OpenMP allows wrap-around for device numbers, enable next line
//Engine& device = mic_engines[device_num % mic_engines_total];
Engine& device = mic_engines[device_num];
// Does host pointer have association already?
// lookup existing association in pointer table
PtrData* ptr_data = device.find_ptr_data(host_ptr);
if (ptr_data != 0) {
OFFLOAD_TRACE(3, "Address %p is already mapped on device %d\n",
host_ptr, device_num);
// Is current device pointer and offset same as existing?
if ((void*)ptr_data->mic_addr == device_ptr &&
(size_t)ptr_data->alloc_disp == device_offset) {
return 0;
} else {
return 1;
}
}
// Create association
OFFLOAD_TRACE(3, "Creating association for data: addr %p, length %lld\n",
host_ptr, size);
bool is_new;
ptr_data = device.insert_ptr_data(host_ptr, size, is_new);
ptr_data->is_omp_associate = true;
// create CPU buffer
OFFLOAD_TRACE(3,
"Creating buffer from source memory %p, length %lld\n",
host_ptr, size);
// result is not checked because we can continue without cpu
// buffer. In this case we will use COIBufferRead/Write
// instead of COIBufferCopy.
COI::BufferCreateFromMemory(size,
COI_BUFFER_OPENCL,
0,
host_ptr,
1,
&device.get_process(),
&ptr_data->cpu_buf);
// create MIC buffer
OFFLOAD_TRACE(3,
"Creating buffer from sink memory: addr %p, size %lld\n",
(char *)device_ptr + device_offset, size);
res = COI::BufferCreateFromMemory(size,
COI_BUFFER_NORMAL,
COI_SINK_MEMORY,
device_ptr,
1,
&device.get_process(),
&ptr_data->mic_buf);
if (res != COI_SUCCESS) {
ptr_data->alloc_ptr_data_lock.unlock();
return 1;
}
// make buffer valid on the device.
res = COI::BufferSetState(ptr_data->mic_buf,
device.get_process(),
COI_BUFFER_VALID,
COI_BUFFER_NO_MOVE,
0, 0, 0);
if (res != COI_SUCCESS) {
ptr_data->alloc_ptr_data_lock.unlock();
return 1;
}
res = COI::BufferSetState(ptr_data->mic_buf,
COI_PROCESS_SOURCE,
COI_BUFFER_INVALID,
COI_BUFFER_NO_MOVE,
0, 0, 0);
if (res != COI_SUCCESS) {
ptr_data->alloc_ptr_data_lock.unlock();
return 1;
}
ptr_data->alloc_disp = device_offset;
ptr_data->alloc_ptr_data_lock.unlock();
return 0;
}
int omp_target_disassociate_ptr(
void *host_ptr,
int device_num
) __GOMP_NOTHROW
{
COIRESULT res;
__offload_init_library();
OFFLOAD_TRACE(2, "omp_target_disassociate_ptr(%p, %d)\n",
host_ptr, device_num);
if (device_num < -1) {
LIBOFFLOAD_ERROR(c_invalid_device_number);
exit(1);
}
// Dissociating from CPU is treated as failure
if (device_num == -1) {
return 1;
}
// If OpenMP allows wrap-around for device numbers, enable next line
//Engine& device = mic_engines[device_num % mic_engines_total];
Engine& device = mic_engines[device_num];
// Lookup existing association in pointer table
PtrData* ptr_data = device.find_ptr_data(host_ptr);
// Attempt to disassociate unassociated pointer is a failure
if (ptr_data == 0) {
return 1;
}
// Destroy buffers
if (ptr_data->cpu_buf != 0) {
OFFLOAD_TRACE(3, "Destroying CPU buffer %p\n", ptr_data->cpu_buf);
COI::BufferDestroy(ptr_data->cpu_buf);
}
if (ptr_data->mic_buf != 0) {
OFFLOAD_TRACE(3, "Destroying MIC buffer %p\n", ptr_data->mic_buf);
COI::BufferDestroy(ptr_data->mic_buf);
}
// Remove association from map
OFFLOAD_TRACE(3, "Removing association for addr %p\n",
ptr_data->cpu_addr.start());
device.remove_ptr_data(ptr_data->cpu_addr.start());
return 0;
}
// End of OpenMP 4.5 APIs
Update gcc to 5.2.0
2015-08-28 15:33:40 +00:00
// OpenMP API wrappers
static void omp_set_int_target(
TARGET_TYPE target_type,
int target_number,
int setting,
const char* f_name
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
f_name, 0);
if (ofld) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(int);
vars[0].count = 1;
vars[0].ptr = &setting;
OFFLOAD_OFFLOAD(ofld, f_name, 0, 1, vars, NULL, 0, 0, 0);
}
}
static int omp_get_int_target(
TARGET_TYPE target_type,
int target_number,
const char * f_name
)
{
int setting = 0;
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
f_name, 0);
if (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].size = sizeof(int);
vars[0].count = 1;
vars[0].ptr = &setting;
OFFLOAD_OFFLOAD(ofld, f_name, 0, 1, vars, NULL, 0, 0, 0);
}
return setting;
}
void omp_set_num_threads_target(
TARGET_TYPE target_type,
int target_number,
int num_threads
)
{
omp_set_int_target(target_type, target_number, num_threads,
"omp_set_num_threads_target");
}
int omp_get_max_threads_target(
TARGET_TYPE target_type,
int target_number
)
{
return omp_get_int_target(target_type, target_number,
"omp_get_max_threads_target");
}
int omp_get_num_procs_target(
TARGET_TYPE target_type,
int target_number
)
{
return omp_get_int_target(target_type, target_number,
"omp_get_num_procs_target");
}
void omp_set_dynamic_target(
TARGET_TYPE target_type,
int target_number,
int num_threads
)
{
omp_set_int_target(target_type, target_number, num_threads,
"omp_set_dynamic_target");
}
int omp_get_dynamic_target(
TARGET_TYPE target_type,
int target_number
)
{
return omp_get_int_target(target_type, target_number,
"omp_get_dynamic_target");
}
void omp_set_nested_target(
TARGET_TYPE target_type,
int target_number,
int nested
)
{
omp_set_int_target(target_type, target_number, nested,
"omp_set_nested_target");
}
int omp_get_nested_target(
TARGET_TYPE target_type,
int target_number
)
{
return omp_get_int_target(target_type, target_number,
"omp_get_nested_target");
}
void omp_set_schedule_target(
TARGET_TYPE target_type,
int target_number,
omp_sched_t kind,
int modifier
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[2] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(omp_sched_t);
vars[0].count = 1;
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].size = sizeof(int);
vars[1].count = 1;
vars[1].ptr = &modifier;
OFFLOAD_OFFLOAD(ofld, "omp_set_schedule_target",
0, 2, vars, NULL, 0, 0, 0);
}
}
void omp_get_schedule_target(
TARGET_TYPE target_type,
int target_number,
omp_sched_t *kind,
int *modifier
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[2] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_out;
vars[0].size = sizeof(omp_sched_t);
vars[0].count = 1;
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].size = sizeof(int);
vars[1].count = 1;
vars[1].ptr = modifier;
OFFLOAD_OFFLOAD(ofld, "omp_get_schedule_target",
0, 2, vars, NULL, 0, 0, 0);
}
}
// lock API functions
void omp_init_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
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].size = sizeof(omp_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_init_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
void omp_destroy_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(omp_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_destroy_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
void omp_set_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_inout;
vars[0].size = sizeof(omp_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_set_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
void omp_unset_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_inout;
vars[0].size = sizeof(omp_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_unset_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
int omp_test_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_lock_target_t *lock
)
{
int result = 0;
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[2] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_inout;
vars[0].size = sizeof(omp_lock_target_t);
vars[0].count = 1;
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].size = sizeof(int);
vars[1].count = 1;
vars[1].ptr = &result;
OFFLOAD_OFFLOAD(ofld, "omp_test_lock_target",
0, 2, vars, NULL, 0, 0, 0);
}
return result;
}
// nested lock API functions
void omp_init_nest_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_nest_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
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].size = sizeof(omp_nest_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_init_nest_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
void omp_destroy_nest_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_nest_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_in;
vars[0].size = sizeof(omp_nest_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_destroy_nest_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
void omp_set_nest_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_nest_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_inout;
vars[0].size = sizeof(omp_nest_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_set_nest_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
void omp_unset_nest_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_nest_lock_target_t *lock
)
{
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[1] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_inout;
vars[0].size = sizeof(omp_nest_lock_target_t);
vars[0].count = 1;
vars[0].ptr = lock;
OFFLOAD_OFFLOAD(ofld, "omp_unset_nest_lock_target",
0, 1, vars, NULL, 0, 0, 0);
}
}
int omp_test_nest_lock_target(
TARGET_TYPE target_type,
int target_number,
omp_nest_lock_target_t *lock
)
{
int result = 0;
OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
__func__, 0);
if (ofld != 0) {
VarDesc vars[2] = {0};
vars[0].type.src = c_data;
vars[0].type.dst = c_data;
vars[0].direction.bits = c_parameter_inout;
vars[0].size = sizeof(omp_nest_lock_target_t);
vars[0].count = 1;
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].size = sizeof(int);
vars[1].count = 1;
vars[1].ptr = &result;
OFFLOAD_OFFLOAD(ofld, "omp_test_nest_lock_target",
0, 2, vars, NULL, 0, 0, 0);
}
return result;
}
Reference in New Issue Copy Permalink