[Openmp-commits] [openmp] r319971 - [libomptarget] Split implementation of API functions
Jonas Hahnfeld via Openmp-commits
openmp-commits at lists.llvm.org
Wed Dec 6 13:59:12 PST 2017
Author: hahnfeld
Date: Wed Dec 6 13:59:12 2017
New Revision: 319971
URL: http://llvm.org/viewvc/llvm-project?rev=319971&view=rev
Log:
[libomptarget] Split implementation of API functions
This third patch moves the implementation of the user-facing
OpenMP API functions into its own file. For now, the code is
only moved, no cleanups applied yet.
Differential Revision: https://reviews.llvm.org/D40800
Added:
openmp/trunk/libomptarget/src/api.cpp
Modified:
openmp/trunk/libomptarget/src/CMakeLists.txt
openmp/trunk/libomptarget/src/device.cpp
openmp/trunk/libomptarget/src/device.h
openmp/trunk/libomptarget/src/omptarget.cpp
Modified: openmp/trunk/libomptarget/src/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/openmp/trunk/libomptarget/src/CMakeLists.txt?rev=319971&r1=319970&r2=319971&view=diff
==============================================================================
--- openmp/trunk/libomptarget/src/CMakeLists.txt (original)
+++ openmp/trunk/libomptarget/src/CMakeLists.txt Wed Dec 6 13:59:12 2017
@@ -14,6 +14,7 @@
libomptarget_say("Building offloading runtime library libomptarget.")
set(src_files
+ api.cpp
device.cpp
rtl.cpp
omptarget.cpp
Added: openmp/trunk/libomptarget/src/api.cpp
URL: http://llvm.org/viewvc/llvm-project/openmp/trunk/libomptarget/src/api.cpp?rev=319971&view=auto
==============================================================================
--- openmp/trunk/libomptarget/src/api.cpp (added)
+++ openmp/trunk/libomptarget/src/api.cpp Wed Dec 6 13:59:12 2017
@@ -0,0 +1,282 @@
+//===----------- api.cpp - Target independent OpenMP target RTL -----------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of OpenMP API interface functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include <omptarget.h>
+
+#include "device.h"
+#include "private.h"
+#include "rtl.h"
+
+#include <climits>
+#include <cstring>
+
+EXTERN int omp_get_num_devices(void) {
+ RTLsMtx.lock();
+ size_t Devices_size = Devices.size();
+ RTLsMtx.unlock();
+
+ DP("Call to omp_get_num_devices returning %zd\n", Devices_size);
+
+ return Devices_size;
+}
+
+EXTERN int omp_get_initial_device(void) {
+ DP("Call to omp_get_initial_device returning %d\n", HOST_DEVICE);
+ return HOST_DEVICE;
+}
+
+EXTERN void *omp_target_alloc(size_t size, int device_num) {
+ DP("Call to omp_target_alloc for device %d requesting %zu bytes\n",
+ device_num, size);
+
+ if (size <= 0) {
+ DP("Call to omp_target_alloc with non-positive length\n");
+ return NULL;
+ }
+
+ void *rc = NULL;
+
+ if (device_num == omp_get_initial_device()) {
+ rc = malloc(size);
+ DP("omp_target_alloc returns host ptr " DPxMOD "\n", DPxPTR(rc));
+ return rc;
+ }
+
+ if (!device_is_ready(device_num)) {
+ DP("omp_target_alloc returns NULL ptr\n");
+ return NULL;
+ }
+
+ DeviceTy &Device = Devices[device_num];
+ rc = Device.RTL->data_alloc(Device.RTLDeviceID, size, NULL);
+ DP("omp_target_alloc returns device ptr " DPxMOD "\n", DPxPTR(rc));
+ return rc;
+}
+
+EXTERN void omp_target_free(void *device_ptr, int device_num) {
+ DP("Call to omp_target_free for device %d and address " DPxMOD "\n",
+ device_num, DPxPTR(device_ptr));
+
+ if (!device_ptr) {
+ DP("Call to omp_target_free with NULL ptr\n");
+ return;
+ }
+
+ if (device_num == omp_get_initial_device()) {
+ free(device_ptr);
+ DP("omp_target_free deallocated host ptr\n");
+ return;
+ }
+
+ if (!device_is_ready(device_num)) {
+ DP("omp_target_free returns, nothing to do\n");
+ return;
+ }
+
+ DeviceTy &Device = Devices[device_num];
+ Device.RTL->data_delete(Device.RTLDeviceID, (void *)device_ptr);
+ DP("omp_target_free deallocated device ptr\n");
+}
+
+EXTERN int omp_target_is_present(void *ptr, int device_num) {
+ DP("Call to omp_target_is_present for device %d and address " DPxMOD "\n",
+ device_num, DPxPTR(ptr));
+
+ if (!ptr) {
+ DP("Call to omp_target_is_present with NULL ptr, returning false\n");
+ return false;
+ }
+
+ if (device_num == omp_get_initial_device()) {
+ DP("Call to omp_target_is_present on host, returning true\n");
+ return true;
+ }
+
+ RTLsMtx.lock();
+ size_t Devices_size = Devices.size();
+ RTLsMtx.unlock();
+ if (Devices_size <= (size_t)device_num) {
+ DP("Call to omp_target_is_present with invalid device ID, returning "
+ "false\n");
+ return false;
+ }
+
+ DeviceTy& Device = Devices[device_num];
+ bool IsLast; // not used
+ int rc = (Device.getTgtPtrBegin(ptr, 0, IsLast, false) != NULL);
+ DP("Call to omp_target_is_present returns %d\n", rc);
+ return rc;
+}
+
+EXTERN 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) {
+ DP("Call to omp_target_memcpy, dst device %d, src device %d, "
+ "dst addr " DPxMOD ", src addr " DPxMOD ", dst offset %zu, "
+ "src offset %zu, length %zu\n", dst_device, src_device, DPxPTR(dst),
+ DPxPTR(src), dst_offset, src_offset, length);
+
+ if (!dst || !src || length <= 0) {
+ DP("Call to omp_target_memcpy with invalid arguments\n");
+ return OFFLOAD_FAIL;
+ }
+
+ if (src_device != omp_get_initial_device() && !device_is_ready(src_device)) {
+ DP("omp_target_memcpy returns OFFLOAD_FAIL\n");
+ return OFFLOAD_FAIL;
+ }
+
+ if (dst_device != omp_get_initial_device() && !device_is_ready(dst_device)) {
+ DP("omp_target_memcpy returns OFFLOAD_FAIL\n");
+ return OFFLOAD_FAIL;
+ }
+
+ int rc = OFFLOAD_SUCCESS;
+ void *srcAddr = (char *)src + src_offset;
+ void *dstAddr = (char *)dst + dst_offset;
+
+ if (src_device == omp_get_initial_device() &&
+ dst_device == omp_get_initial_device()) {
+ DP("copy from host to host\n");
+ const void *p = memcpy(dstAddr, srcAddr, length);
+ if (p == NULL)
+ rc = OFFLOAD_FAIL;
+ } else if (src_device == omp_get_initial_device()) {
+ DP("copy from host to device\n");
+ DeviceTy& DstDev = Devices[dst_device];
+ rc = DstDev.data_submit(dstAddr, srcAddr, length);
+ } else if (dst_device == omp_get_initial_device()) {
+ DP("copy from device to host\n");
+ DeviceTy& SrcDev = Devices[src_device];
+ rc = SrcDev.data_retrieve(dstAddr, srcAddr, length);
+ } else {
+ DP("copy from device to device\n");
+ void *buffer = malloc(length);
+ DeviceTy& SrcDev = Devices[src_device];
+ DeviceTy& DstDev = Devices[dst_device];
+ rc = SrcDev.data_retrieve(buffer, srcAddr, length);
+ if (rc == OFFLOAD_SUCCESS)
+ rc = DstDev.data_submit(dstAddr, buffer, length);
+ }
+
+ DP("omp_target_memcpy returns %d\n", rc);
+ return rc;
+}
+
+EXTERN 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) {
+ DP("Call to omp_target_memcpy_rect, dst device %d, src device %d, "
+ "dst addr " DPxMOD ", src addr " DPxMOD ", dst offsets " DPxMOD ", "
+ "src offsets " DPxMOD ", dst dims " DPxMOD ", src dims " DPxMOD ", "
+ "volume " DPxMOD ", element size %zu, num_dims %d\n", dst_device,
+ src_device, DPxPTR(dst), DPxPTR(src), DPxPTR(dst_offsets),
+ DPxPTR(src_offsets), DPxPTR(dst_dimensions), DPxPTR(src_dimensions),
+ DPxPTR(volume), element_size, num_dims);
+
+ if (!(dst || src)) {
+ DP("Call to omp_target_memcpy_rect returns max supported dimensions %d\n",
+ INT_MAX);
+ return INT_MAX;
+ }
+
+ if (!dst || !src || element_size < 1 || num_dims < 1 || !volume ||
+ !dst_offsets || !src_offsets || !dst_dimensions || !src_dimensions) {
+ DP("Call to omp_target_memcpy_rect with invalid arguments\n");
+ return OFFLOAD_FAIL;
+ }
+
+ int rc;
+ if (num_dims == 1) {
+ rc = omp_target_memcpy(dst, src, element_size * volume[0],
+ element_size * dst_offsets[0], element_size * src_offsets[0],
+ dst_device, src_device);
+ } else {
+ size_t dst_slice_size = element_size;
+ size_t src_slice_size = element_size;
+ for (int i=1; i<num_dims; ++i) {
+ dst_slice_size *= dst_dimensions[i];
+ src_slice_size *= src_dimensions[i];
+ }
+
+ size_t dst_off = dst_offsets[0] * dst_slice_size;
+ size_t src_off = src_offsets[0] * src_slice_size;
+ for (size_t i=0; i<volume[0]; ++i) {
+ rc = omp_target_memcpy_rect((char *) dst + dst_off + dst_slice_size * i,
+ (char *) src + src_off + src_slice_size * i, element_size,
+ num_dims - 1, volume + 1, dst_offsets + 1, src_offsets + 1,
+ dst_dimensions + 1, src_dimensions + 1, dst_device, src_device);
+
+ if (rc) {
+ DP("Recursive call to omp_target_memcpy_rect returns unsuccessfully\n");
+ return rc;
+ }
+ }
+ }
+
+ DP("omp_target_memcpy_rect returns %d\n", rc);
+ return rc;
+}
+
+EXTERN int omp_target_associate_ptr(void *host_ptr, void *device_ptr,
+ size_t size, size_t device_offset, int device_num) {
+ DP("Call to omp_target_associate_ptr with host_ptr " DPxMOD ", "
+ "device_ptr " DPxMOD ", size %zu, device_offset %zu, device_num %d\n",
+ DPxPTR(host_ptr), DPxPTR(device_ptr), size, device_offset, device_num);
+
+ if (!host_ptr || !device_ptr || size <= 0) {
+ DP("Call to omp_target_associate_ptr with invalid arguments\n");
+ return OFFLOAD_FAIL;
+ }
+
+ if (device_num == omp_get_initial_device()) {
+ DP("omp_target_associate_ptr: no association possible on the host\n");
+ return OFFLOAD_FAIL;
+ }
+
+ if (!device_is_ready(device_num)) {
+ DP("omp_target_associate_ptr returns OFFLOAD_FAIL\n");
+ return OFFLOAD_FAIL;
+ }
+
+ DeviceTy& Device = Devices[device_num];
+ void *device_addr = (void *)((uint64_t)device_ptr + (uint64_t)device_offset);
+ int rc = Device.associatePtr(host_ptr, device_addr, size);
+ DP("omp_target_associate_ptr returns %d\n", rc);
+ return rc;
+}
+
+EXTERN int omp_target_disassociate_ptr(void *host_ptr, int device_num) {
+ DP("Call to omp_target_disassociate_ptr with host_ptr " DPxMOD ", "
+ "device_num %d\n", DPxPTR(host_ptr), device_num);
+
+ if (!host_ptr) {
+ DP("Call to omp_target_associate_ptr with invalid host_ptr\n");
+ return OFFLOAD_FAIL;
+ }
+
+ if (device_num == omp_get_initial_device()) {
+ DP("omp_target_disassociate_ptr: no association possible on the host\n");
+ return OFFLOAD_FAIL;
+ }
+
+ if (!device_is_ready(device_num)) {
+ DP("omp_target_disassociate_ptr returns OFFLOAD_FAIL\n");
+ return OFFLOAD_FAIL;
+ }
+
+ DeviceTy& Device = Devices[device_num];
+ int rc = Device.disassociatePtr(host_ptr);
+ DP("omp_target_disassociate_ptr returns %d\n", rc);
+ return rc;
+}
Modified: openmp/trunk/libomptarget/src/device.cpp
URL: http://llvm.org/viewvc/llvm-project/openmp/trunk/libomptarget/src/device.cpp?rev=319971&r1=319970&r2=319971&view=diff
==============================================================================
--- openmp/trunk/libomptarget/src/device.cpp (original)
+++ openmp/trunk/libomptarget/src/device.cpp Wed Dec 6 13:59:12 2017
@@ -332,3 +332,34 @@ int32_t DeviceTy::run_team_region(void *
return RTL->run_team_region(RTLDeviceID, TgtEntryPtr, TgtVarsPtr, TgtOffsets,
TgtVarsSize, NumTeams, ThreadLimit, LoopTripCount);
}
+
+/// Check whether a device has an associated RTL and initialize it if it's not
+/// already initialized.
+bool device_is_ready(int device_num) {
+ DP("Checking whether device %d is ready.\n", device_num);
+ // Devices.size() can only change while registering a new
+ // library, so try to acquire the lock of RTLs' mutex.
+ RTLsMtx.lock();
+ size_t Devices_size = Devices.size();
+ RTLsMtx.unlock();
+ if (Devices_size <= (size_t)device_num) {
+ DP("Device ID %d does not have a matching RTL\n", device_num);
+ return false;
+ }
+
+ // Get device info
+ DeviceTy &Device = Devices[device_num];
+
+ DP("Is the device %d (local ID %d) initialized? %d\n", device_num,
+ Device.RTLDeviceID, Device.IsInit);
+
+ // Init the device if not done before
+ if (!Device.IsInit && Device.initOnce() != OFFLOAD_SUCCESS) {
+ DP("Failed to init device %d\n", device_num);
+ return false;
+ }
+
+ DP("Device %d is ready to use.\n", device_num);
+
+ return true;
+}
Modified: openmp/trunk/libomptarget/src/device.h
URL: http://llvm.org/viewvc/llvm-project/openmp/trunk/libomptarget/src/device.h?rev=319971&r1=319970&r2=319971&view=diff
==============================================================================
--- openmp/trunk/libomptarget/src/device.h (original)
+++ openmp/trunk/libomptarget/src/device.h Wed Dec 6 13:59:12 2017
@@ -162,4 +162,6 @@ private:
typedef std::vector<DeviceTy> DevicesTy;
extern DevicesTy Devices;
+extern bool device_is_ready(int device_num);
+
#endif
Modified: openmp/trunk/libomptarget/src/omptarget.cpp
URL: http://llvm.org/viewvc/llvm-project/openmp/trunk/libomptarget/src/omptarget.cpp?rev=319971&r1=319970&r2=319971&view=diff
==============================================================================
--- openmp/trunk/libomptarget/src/omptarget.cpp (original)
+++ openmp/trunk/libomptarget/src/omptarget.cpp Wed Dec 6 13:59:12 2017
@@ -19,309 +19,12 @@
#include "rtl.h"
#include <cassert>
-#include <climits>
-#include <cstring>
#include <vector>
#ifdef OMPTARGET_DEBUG
int DebugLevel = 0;
#endif // OMPTARGET_DEBUG
-/// Check whether a device has an associated RTL and initialize it if it's not
-/// already initialized.
-static bool device_is_ready(int device_num) {
- DP("Checking whether device %d is ready.\n", device_num);
- // Devices.size() can only change while registering a new
- // library, so try to acquire the lock of RTLs' mutex.
- RTLsMtx.lock();
- size_t Devices_size = Devices.size();
- RTLsMtx.unlock();
- if (Devices_size <= (size_t)device_num) {
- DP("Device ID %d does not have a matching RTL\n", device_num);
- return false;
- }
-
- // Get device info
- DeviceTy &Device = Devices[device_num];
-
- DP("Is the device %d (local ID %d) initialized? %d\n", device_num,
- Device.RTLDeviceID, Device.IsInit);
-
- // Init the device if not done before
- if (!Device.IsInit && Device.initOnce() != OFFLOAD_SUCCESS) {
- DP("Failed to init device %d\n", device_num);
- return false;
- }
-
- DP("Device %d is ready to use.\n", device_num);
-
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Target API functions
-//
-EXTERN int omp_get_num_devices(void) {
- RTLsMtx.lock();
- size_t Devices_size = Devices.size();
- RTLsMtx.unlock();
-
- DP("Call to omp_get_num_devices returning %zd\n", Devices_size);
-
- return Devices_size;
-}
-
-EXTERN int omp_get_initial_device(void) {
- DP("Call to omp_get_initial_device returning %d\n", HOST_DEVICE);
- return HOST_DEVICE;
-}
-
-EXTERN void *omp_target_alloc(size_t size, int device_num) {
- DP("Call to omp_target_alloc for device %d requesting %zu bytes\n",
- device_num, size);
-
- if (size <= 0) {
- DP("Call to omp_target_alloc with non-positive length\n");
- return NULL;
- }
-
- void *rc = NULL;
-
- if (device_num == omp_get_initial_device()) {
- rc = malloc(size);
- DP("omp_target_alloc returns host ptr " DPxMOD "\n", DPxPTR(rc));
- return rc;
- }
-
- if (!device_is_ready(device_num)) {
- DP("omp_target_alloc returns NULL ptr\n");
- return NULL;
- }
-
- DeviceTy &Device = Devices[device_num];
- rc = Device.RTL->data_alloc(Device.RTLDeviceID, size, NULL);
- DP("omp_target_alloc returns device ptr " DPxMOD "\n", DPxPTR(rc));
- return rc;
-}
-
-EXTERN void omp_target_free(void *device_ptr, int device_num) {
- DP("Call to omp_target_free for device %d and address " DPxMOD "\n",
- device_num, DPxPTR(device_ptr));
-
- if (!device_ptr) {
- DP("Call to omp_target_free with NULL ptr\n");
- return;
- }
-
- if (device_num == omp_get_initial_device()) {
- free(device_ptr);
- DP("omp_target_free deallocated host ptr\n");
- return;
- }
-
- if (!device_is_ready(device_num)) {
- DP("omp_target_free returns, nothing to do\n");
- return;
- }
-
- DeviceTy &Device = Devices[device_num];
- Device.RTL->data_delete(Device.RTLDeviceID, (void *)device_ptr);
- DP("omp_target_free deallocated device ptr\n");
-}
-
-EXTERN int omp_target_is_present(void *ptr, int device_num) {
- DP("Call to omp_target_is_present for device %d and address " DPxMOD "\n",
- device_num, DPxPTR(ptr));
-
- if (!ptr) {
- DP("Call to omp_target_is_present with NULL ptr, returning false\n");
- return false;
- }
-
- if (device_num == omp_get_initial_device()) {
- DP("Call to omp_target_is_present on host, returning true\n");
- return true;
- }
-
- RTLsMtx.lock();
- size_t Devices_size = Devices.size();
- RTLsMtx.unlock();
- if (Devices_size <= (size_t)device_num) {
- DP("Call to omp_target_is_present with invalid device ID, returning "
- "false\n");
- return false;
- }
-
- DeviceTy& Device = Devices[device_num];
- bool IsLast; // not used
- int rc = (Device.getTgtPtrBegin(ptr, 0, IsLast, false) != NULL);
- DP("Call to omp_target_is_present returns %d\n", rc);
- return rc;
-}
-
-EXTERN 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) {
- DP("Call to omp_target_memcpy, dst device %d, src device %d, "
- "dst addr " DPxMOD ", src addr " DPxMOD ", dst offset %zu, "
- "src offset %zu, length %zu\n", dst_device, src_device, DPxPTR(dst),
- DPxPTR(src), dst_offset, src_offset, length);
-
- if (!dst || !src || length <= 0) {
- DP("Call to omp_target_memcpy with invalid arguments\n");
- return OFFLOAD_FAIL;
- }
-
- if (src_device != omp_get_initial_device() && !device_is_ready(src_device)) {
- DP("omp_target_memcpy returns OFFLOAD_FAIL\n");
- return OFFLOAD_FAIL;
- }
-
- if (dst_device != omp_get_initial_device() && !device_is_ready(dst_device)) {
- DP("omp_target_memcpy returns OFFLOAD_FAIL\n");
- return OFFLOAD_FAIL;
- }
-
- int rc = OFFLOAD_SUCCESS;
- void *srcAddr = (char *)src + src_offset;
- void *dstAddr = (char *)dst + dst_offset;
-
- if (src_device == omp_get_initial_device() &&
- dst_device == omp_get_initial_device()) {
- DP("copy from host to host\n");
- const void *p = memcpy(dstAddr, srcAddr, length);
- if (p == NULL)
- rc = OFFLOAD_FAIL;
- } else if (src_device == omp_get_initial_device()) {
- DP("copy from host to device\n");
- DeviceTy& DstDev = Devices[dst_device];
- rc = DstDev.data_submit(dstAddr, srcAddr, length);
- } else if (dst_device == omp_get_initial_device()) {
- DP("copy from device to host\n");
- DeviceTy& SrcDev = Devices[src_device];
- rc = SrcDev.data_retrieve(dstAddr, srcAddr, length);
- } else {
- DP("copy from device to device\n");
- void *buffer = malloc(length);
- DeviceTy& SrcDev = Devices[src_device];
- DeviceTy& DstDev = Devices[dst_device];
- rc = SrcDev.data_retrieve(buffer, srcAddr, length);
- if (rc == OFFLOAD_SUCCESS)
- rc = DstDev.data_submit(dstAddr, buffer, length);
- }
-
- DP("omp_target_memcpy returns %d\n", rc);
- return rc;
-}
-
-EXTERN 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) {
- DP("Call to omp_target_memcpy_rect, dst device %d, src device %d, "
- "dst addr " DPxMOD ", src addr " DPxMOD ", dst offsets " DPxMOD ", "
- "src offsets " DPxMOD ", dst dims " DPxMOD ", src dims " DPxMOD ", "
- "volume " DPxMOD ", element size %zu, num_dims %d\n", dst_device,
- src_device, DPxPTR(dst), DPxPTR(src), DPxPTR(dst_offsets),
- DPxPTR(src_offsets), DPxPTR(dst_dimensions), DPxPTR(src_dimensions),
- DPxPTR(volume), element_size, num_dims);
-
- if (!(dst || src)) {
- DP("Call to omp_target_memcpy_rect returns max supported dimensions %d\n",
- INT_MAX);
- return INT_MAX;
- }
-
- if (!dst || !src || element_size < 1 || num_dims < 1 || !volume ||
- !dst_offsets || !src_offsets || !dst_dimensions || !src_dimensions) {
- DP("Call to omp_target_memcpy_rect with invalid arguments\n");
- return OFFLOAD_FAIL;
- }
-
- int rc;
- if (num_dims == 1) {
- rc = omp_target_memcpy(dst, src, element_size * volume[0],
- element_size * dst_offsets[0], element_size * src_offsets[0],
- dst_device, src_device);
- } else {
- size_t dst_slice_size = element_size;
- size_t src_slice_size = element_size;
- for (int i=1; i<num_dims; ++i) {
- dst_slice_size *= dst_dimensions[i];
- src_slice_size *= src_dimensions[i];
- }
-
- size_t dst_off = dst_offsets[0] * dst_slice_size;
- size_t src_off = src_offsets[0] * src_slice_size;
- for (size_t i=0; i<volume[0]; ++i) {
- rc = omp_target_memcpy_rect((char *) dst + dst_off + dst_slice_size * i,
- (char *) src + src_off + src_slice_size * i, element_size,
- num_dims - 1, volume + 1, dst_offsets + 1, src_offsets + 1,
- dst_dimensions + 1, src_dimensions + 1, dst_device, src_device);
-
- if (rc) {
- DP("Recursive call to omp_target_memcpy_rect returns unsuccessfully\n");
- return rc;
- }
- }
- }
-
- DP("omp_target_memcpy_rect returns %d\n", rc);
- return rc;
-}
-
-EXTERN int omp_target_associate_ptr(void *host_ptr, void *device_ptr,
- size_t size, size_t device_offset, int device_num) {
- DP("Call to omp_target_associate_ptr with host_ptr " DPxMOD ", "
- "device_ptr " DPxMOD ", size %zu, device_offset %zu, device_num %d\n",
- DPxPTR(host_ptr), DPxPTR(device_ptr), size, device_offset, device_num);
-
- if (!host_ptr || !device_ptr || size <= 0) {
- DP("Call to omp_target_associate_ptr with invalid arguments\n");
- return OFFLOAD_FAIL;
- }
-
- if (device_num == omp_get_initial_device()) {
- DP("omp_target_associate_ptr: no association possible on the host\n");
- return OFFLOAD_FAIL;
- }
-
- if (!device_is_ready(device_num)) {
- DP("omp_target_associate_ptr returns OFFLOAD_FAIL\n");
- return OFFLOAD_FAIL;
- }
-
- DeviceTy& Device = Devices[device_num];
- void *device_addr = (void *)((uint64_t)device_ptr + (uint64_t)device_offset);
- int rc = Device.associatePtr(host_ptr, device_addr, size);
- DP("omp_target_associate_ptr returns %d\n", rc);
- return rc;
-}
-
-EXTERN int omp_target_disassociate_ptr(void *host_ptr, int device_num) {
- DP("Call to omp_target_disassociate_ptr with host_ptr " DPxMOD ", "
- "device_num %d\n", DPxPTR(host_ptr), device_num);
-
- if (!host_ptr) {
- DP("Call to omp_target_associate_ptr with invalid host_ptr\n");
- return OFFLOAD_FAIL;
- }
-
- if (device_num == omp_get_initial_device()) {
- DP("omp_target_disassociate_ptr: no association possible on the host\n");
- return OFFLOAD_FAIL;
- }
-
- if (!device_is_ready(device_num)) {
- DP("omp_target_disassociate_ptr returns OFFLOAD_FAIL\n");
- return OFFLOAD_FAIL;
- }
-
- DeviceTy& Device = Devices[device_num];
- int rc = Device.disassociatePtr(host_ptr);
- DP("omp_target_disassociate_ptr returns %d\n", rc);
- return rc;
-}
-
////////////////////////////////////////////////////////////////////////////////
/// adds a target shared library to the target execution image
EXTERN void __tgt_register_lib(__tgt_bin_desc *desc) {
More information about the Openmp-commits
mailing list