1 //===----------- api.cpp - Target independent OpenMP target RTL -----------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.txt for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Implementation of OpenMP API interface functions.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include <omptarget.h>
15 
16 #include "device.h"
17 #include "private.h"
18 #include "rtl.h"
19 
20 #include <climits>
21 #include <cstring>
22 
23 EXTERN int omp_get_num_devices(void) {
24   RTLsMtx.lock();
25   size_t Devices_size = Devices.size();
26   RTLsMtx.unlock();
27 
28   DP("Call to omp_get_num_devices returning %zd\n", Devices_size);
29 
30   return Devices_size;
31 }
32 
33 EXTERN int omp_get_initial_device(void) {
34   DP("Call to omp_get_initial_device returning %d\n", HOST_DEVICE);
35   return HOST_DEVICE;
36 }
37 
38 EXTERN void *omp_target_alloc(size_t size, int device_num) {
39   DP("Call to omp_target_alloc for device %d requesting %zu bytes\n",
40       device_num, size);
41 
42   if (size <= 0) {
43     DP("Call to omp_target_alloc with non-positive length\n");
44     return NULL;
45   }
46 
47   void *rc = NULL;
48 
49   if (device_num == omp_get_initial_device()) {
50     rc = malloc(size);
51     DP("omp_target_alloc returns host ptr " DPxMOD "\n", DPxPTR(rc));
52     return rc;
53   }
54 
55   if (!device_is_ready(device_num)) {
56     DP("omp_target_alloc returns NULL ptr\n");
57     return NULL;
58   }
59 
60   DeviceTy &Device = Devices[device_num];
61   rc = Device.RTL->data_alloc(Device.RTLDeviceID, size, NULL);
62   DP("omp_target_alloc returns device ptr " DPxMOD "\n", DPxPTR(rc));
63   return rc;
64 }
65 
66 EXTERN void omp_target_free(void *device_ptr, int device_num) {
67   DP("Call to omp_target_free for device %d and address " DPxMOD "\n",
68       device_num, DPxPTR(device_ptr));
69 
70   if (!device_ptr) {
71     DP("Call to omp_target_free with NULL ptr\n");
72     return;
73   }
74 
75   if (device_num == omp_get_initial_device()) {
76     free(device_ptr);
77     DP("omp_target_free deallocated host ptr\n");
78     return;
79   }
80 
81   if (!device_is_ready(device_num)) {
82     DP("omp_target_free returns, nothing to do\n");
83     return;
84   }
85 
86   DeviceTy &Device = Devices[device_num];
87   Device.RTL->data_delete(Device.RTLDeviceID, (void *)device_ptr);
88   DP("omp_target_free deallocated device ptr\n");
89 }
90 
91 EXTERN int omp_target_is_present(void *ptr, int device_num) {
92   DP("Call to omp_target_is_present for device %d and address " DPxMOD "\n",
93       device_num, DPxPTR(ptr));
94 
95   if (!ptr) {
96     DP("Call to omp_target_is_present with NULL ptr, returning false\n");
97     return false;
98   }
99 
100   if (device_num == omp_get_initial_device()) {
101     DP("Call to omp_target_is_present on host, returning true\n");
102     return true;
103   }
104 
105   RTLsMtx.lock();
106   size_t Devices_size = Devices.size();
107   RTLsMtx.unlock();
108   if (Devices_size <= (size_t)device_num) {
109     DP("Call to omp_target_is_present with invalid device ID, returning "
110         "false\n");
111     return false;
112   }
113 
114   DeviceTy& Device = Devices[device_num];
115   bool IsLast; // not used
116   int rc = (Device.getTgtPtrBegin(ptr, 0, IsLast, false) != NULL);
117   DP("Call to omp_target_is_present returns %d\n", rc);
118   return rc;
119 }
120 
121 EXTERN int omp_target_memcpy(void *dst, void *src, size_t length,
122     size_t dst_offset, size_t src_offset, int dst_device, int src_device) {
123   DP("Call to omp_target_memcpy, dst device %d, src device %d, "
124       "dst addr " DPxMOD ", src addr " DPxMOD ", dst offset %zu, "
125       "src offset %zu, length %zu\n", dst_device, src_device, DPxPTR(dst),
126       DPxPTR(src), dst_offset, src_offset, length);
127 
128   if (!dst || !src || length <= 0) {
129     DP("Call to omp_target_memcpy with invalid arguments\n");
130     return OFFLOAD_FAIL;
131   }
132 
133   if (src_device != omp_get_initial_device() && !device_is_ready(src_device)) {
134       DP("omp_target_memcpy returns OFFLOAD_FAIL\n");
135       return OFFLOAD_FAIL;
136   }
137 
138   if (dst_device != omp_get_initial_device() && !device_is_ready(dst_device)) {
139       DP("omp_target_memcpy returns OFFLOAD_FAIL\n");
140       return OFFLOAD_FAIL;
141   }
142 
143   int rc = OFFLOAD_SUCCESS;
144   void *srcAddr = (char *)src + src_offset;
145   void *dstAddr = (char *)dst + dst_offset;
146 
147   if (src_device == omp_get_initial_device() &&
148       dst_device == omp_get_initial_device()) {
149     DP("copy from host to host\n");
150     const void *p = memcpy(dstAddr, srcAddr, length);
151     if (p == NULL)
152       rc = OFFLOAD_FAIL;
153   } else if (src_device == omp_get_initial_device()) {
154     DP("copy from host to device\n");
155     DeviceTy& DstDev = Devices[dst_device];
156     rc = DstDev.data_submit(dstAddr, srcAddr, length);
157   } else if (dst_device == omp_get_initial_device()) {
158     DP("copy from device to host\n");
159     DeviceTy& SrcDev = Devices[src_device];
160     rc = SrcDev.data_retrieve(dstAddr, srcAddr, length);
161   } else {
162     DP("copy from device to device\n");
163     void *buffer = malloc(length);
164     DeviceTy& SrcDev = Devices[src_device];
165     DeviceTy& DstDev = Devices[dst_device];
166     rc = SrcDev.data_retrieve(buffer, srcAddr, length);
167     if (rc == OFFLOAD_SUCCESS)
168       rc = DstDev.data_submit(dstAddr, buffer, length);
169   }
170 
171   DP("omp_target_memcpy returns %d\n", rc);
172   return rc;
173 }
174 
175 EXTERN int omp_target_memcpy_rect(void *dst, void *src, size_t element_size,
176     int num_dims, const size_t *volume, const size_t *dst_offsets,
177     const size_t *src_offsets, const size_t *dst_dimensions,
178     const size_t *src_dimensions, int dst_device, int src_device) {
179   DP("Call to omp_target_memcpy_rect, dst device %d, src device %d, "
180       "dst addr " DPxMOD ", src addr " DPxMOD ", dst offsets " DPxMOD ", "
181       "src offsets " DPxMOD ", dst dims " DPxMOD ", src dims " DPxMOD ", "
182       "volume " DPxMOD ", element size %zu, num_dims %d\n", dst_device,
183       src_device, DPxPTR(dst), DPxPTR(src), DPxPTR(dst_offsets),
184       DPxPTR(src_offsets), DPxPTR(dst_dimensions), DPxPTR(src_dimensions),
185       DPxPTR(volume), element_size, num_dims);
186 
187   if (!(dst || src)) {
188     DP("Call to omp_target_memcpy_rect returns max supported dimensions %d\n",
189         INT_MAX);
190     return INT_MAX;
191   }
192 
193   if (!dst || !src || element_size < 1 || num_dims < 1 || !volume ||
194       !dst_offsets || !src_offsets || !dst_dimensions || !src_dimensions) {
195     DP("Call to omp_target_memcpy_rect with invalid arguments\n");
196     return OFFLOAD_FAIL;
197   }
198 
199   int rc;
200   if (num_dims == 1) {
201     rc = omp_target_memcpy(dst, src, element_size * volume[0],
202         element_size * dst_offsets[0], element_size * src_offsets[0],
203         dst_device, src_device);
204   } else {
205     size_t dst_slice_size = element_size;
206     size_t src_slice_size = element_size;
207     for (int i=1; i<num_dims; ++i) {
208       dst_slice_size *= dst_dimensions[i];
209       src_slice_size *= src_dimensions[i];
210     }
211 
212     size_t dst_off = dst_offsets[0] * dst_slice_size;
213     size_t src_off = src_offsets[0] * src_slice_size;
214     for (size_t i=0; i<volume[0]; ++i) {
215       rc = omp_target_memcpy_rect((char *) dst + dst_off + dst_slice_size * i,
216           (char *) src + src_off + src_slice_size * i, element_size,
217           num_dims - 1, volume + 1, dst_offsets + 1, src_offsets + 1,
218           dst_dimensions + 1, src_dimensions + 1, dst_device, src_device);
219 
220       if (rc) {
221         DP("Recursive call to omp_target_memcpy_rect returns unsuccessfully\n");
222         return rc;
223       }
224     }
225   }
226 
227   DP("omp_target_memcpy_rect returns %d\n", rc);
228   return rc;
229 }
230 
231 EXTERN int omp_target_associate_ptr(void *host_ptr, void *device_ptr,
232     size_t size, size_t device_offset, int device_num) {
233   DP("Call to omp_target_associate_ptr with host_ptr " DPxMOD ", "
234       "device_ptr " DPxMOD ", size %zu, device_offset %zu, device_num %d\n",
235       DPxPTR(host_ptr), DPxPTR(device_ptr), size, device_offset, device_num);
236 
237   if (!host_ptr || !device_ptr || size <= 0) {
238     DP("Call to omp_target_associate_ptr with invalid arguments\n");
239     return OFFLOAD_FAIL;
240   }
241 
242   if (device_num == omp_get_initial_device()) {
243     DP("omp_target_associate_ptr: no association possible on the host\n");
244     return OFFLOAD_FAIL;
245   }
246 
247   if (!device_is_ready(device_num)) {
248     DP("omp_target_associate_ptr returns OFFLOAD_FAIL\n");
249     return OFFLOAD_FAIL;
250   }
251 
252   DeviceTy& Device = Devices[device_num];
253   void *device_addr = (void *)((uint64_t)device_ptr + (uint64_t)device_offset);
254   int rc = Device.associatePtr(host_ptr, device_addr, size);
255   DP("omp_target_associate_ptr returns %d\n", rc);
256   return rc;
257 }
258 
259 EXTERN int omp_target_disassociate_ptr(void *host_ptr, int device_num) {
260   DP("Call to omp_target_disassociate_ptr with host_ptr " DPxMOD ", "
261       "device_num %d\n", DPxPTR(host_ptr), device_num);
262 
263   if (!host_ptr) {
264     DP("Call to omp_target_associate_ptr with invalid host_ptr\n");
265     return OFFLOAD_FAIL;
266   }
267 
268   if (device_num == omp_get_initial_device()) {
269     DP("omp_target_disassociate_ptr: no association possible on the host\n");
270     return OFFLOAD_FAIL;
271   }
272 
273   if (!device_is_ready(device_num)) {
274     DP("omp_target_disassociate_ptr returns OFFLOAD_FAIL\n");
275     return OFFLOAD_FAIL;
276   }
277 
278   DeviceTy& Device = Devices[device_num];
279   int rc = Device.disassociatePtr(host_ptr);
280   DP("omp_target_disassociate_ptr returns %d\n", rc);
281   return rc;
282 }
283