|
111
|
1 /* Plugin for offload execution on Intel MIC devices.
|
|
|
2
|
|
|
3 Copyright (C) 2014-2016 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 Contributed by Ilya Verbin <ilya.verbin@intel.com>.
|
|
|
6
|
|
|
7 This file is part of the GNU Offloading and Multi Processing Library
|
|
|
8 (libgomp).
|
|
|
9
|
|
|
10 Libgomp is free software; you can redistribute it and/or modify it
|
|
|
11 under the terms of the GNU General Public License as published by
|
|
|
12 the Free Software Foundation; either version 3, or (at your option)
|
|
|
13 any later version.
|
|
|
14
|
|
|
15 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
|
17 FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
18 more details.
|
|
|
19
|
|
|
20 Under Section 7 of GPL version 3, you are granted additional
|
|
|
21 permissions described in the GCC Runtime Library Exception, version
|
|
|
22 3.1, as published by the Free Software Foundation.
|
|
|
23
|
|
|
24 You should have received a copy of the GNU General Public License and
|
|
|
25 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
26 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
27 <http://www.gnu.org/licenses/>. */
|
|
|
28
|
|
|
29 /* Host side part of a libgomp plugin. */
|
|
|
30
|
|
|
31 #include <stdint.h>
|
|
|
32 #include <stdio.h>
|
|
|
33 #include <stdlib.h>
|
|
|
34 #include <string.h>
|
|
|
35 #include <utility>
|
|
|
36 #include <vector>
|
|
|
37 #include <map>
|
|
|
38 #include "libgomp-plugin.h"
|
|
|
39 #include "compiler_if_host.h"
|
|
|
40 #include "main_target_image.h"
|
|
|
41 #include "gomp-constants.h"
|
|
|
42
|
|
|
43 #define OFFLOAD_ACTIVE_WAIT_ENV "OFFLOAD_ACTIVE_WAIT"
|
|
|
44
|
|
|
45 #ifdef DEBUG
|
|
|
46 #define TRACE(...) \
|
|
|
47 { \
|
|
|
48 fprintf (stderr, "HOST:\t%s:%s ", __FILE__, __FUNCTION__); \
|
|
|
49 fprintf (stderr, __VA_ARGS__); \
|
|
|
50 fprintf (stderr, "\n"); \
|
|
|
51 }
|
|
|
52 #else
|
|
|
53 #define TRACE { }
|
|
|
54 #endif
|
|
|
55
|
|
|
56
|
|
|
57 /* Start/end addresses of functions and global variables on a device. */
|
|
|
58 typedef std::vector<addr_pair> AddrVect;
|
|
|
59
|
|
|
60 /* Addresses for one image and all devices. */
|
|
|
61 typedef std::vector<AddrVect> DevAddrVect;
|
|
|
62
|
|
|
63 /* Addresses for all images and all devices. */
|
|
|
64 typedef std::map<const void *, DevAddrVect> ImgDevAddrMap;
|
|
|
65
|
|
|
66 /* Image descriptor needed by __offload_[un]register_image. */
|
|
|
67 struct TargetImageDesc {
|
|
|
68 int64_t size;
|
|
|
69 /* 10 characters is enough for max int value. */
|
|
|
70 char name[sizeof ("lib0000000000.so")];
|
|
|
71 char data[];
|
|
|
72 };
|
|
|
73
|
|
|
74 /* Image descriptors, indexed by a pointer obtained from libgomp. */
|
|
|
75 typedef std::map<const void *, TargetImageDesc *> ImgDescMap;
|
|
|
76
|
|
|
77
|
|
|
78 /* Total number of available devices. */
|
|
|
79 static int num_devices;
|
|
|
80
|
|
|
81 /* Total number of shared libraries with offloading to Intel MIC. */
|
|
|
82 static int num_images;
|
|
|
83
|
|
|
84 /* Two dimensional array: one key is a pointer to image,
|
|
|
85 second key is number of device. Contains a vector of pointer pairs. */
|
|
|
86 static ImgDevAddrMap *address_table;
|
|
|
87
|
|
|
88 /* Descriptors of all images, registered in liboffloadmic. */
|
|
|
89 static ImgDescMap *image_descriptors;
|
|
|
90
|
|
|
91 /* Thread-safe registration of the main image. */
|
|
|
92 static pthread_once_t main_image_is_registered = PTHREAD_ONCE_INIT;
|
|
|
93
|
|
|
94 static VarDesc vd_host2tgt = {
|
|
|
95 { 1, 1 }, /* dst, src */
|
|
|
96 { 1, 0 }, /* in, out */
|
|
|
97 1, /* alloc_if */
|
|
|
98 1, /* free_if */
|
|
|
99 4, /* align */
|
|
|
100 0, /* mic_offset */
|
|
|
101 { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
|
|
|
102 is_stack_buf, sink_addr, alloc_disp,
|
|
|
103 is_noncont_src, is_noncont_dst */
|
|
|
104 0, /* offset */
|
|
|
105 0, /* size */
|
|
|
106 1, /* count */
|
|
|
107 0, /* alloc */
|
|
|
108 0, /* into */
|
|
|
109 0 /* ptr */
|
|
|
110 };
|
|
|
111
|
|
|
112 static VarDesc vd_tgt2host = {
|
|
|
113 { 1, 1 }, /* dst, src */
|
|
|
114 { 0, 1 }, /* in, out */
|
|
|
115 1, /* alloc_if */
|
|
|
116 1, /* free_if */
|
|
|
117 4, /* align */
|
|
|
118 0, /* mic_offset */
|
|
|
119 { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
|
|
|
120 is_stack_buf, sink_addr, alloc_disp,
|
|
|
121 is_noncont_src, is_noncont_dst */
|
|
|
122 0, /* offset */
|
|
|
123 0, /* size */
|
|
|
124 1, /* count */
|
|
|
125 0, /* alloc */
|
|
|
126 0, /* into */
|
|
|
127 0 /* ptr */
|
|
|
128 };
|
|
|
129
|
|
|
130
|
|
|
131 __attribute__((constructor))
|
|
|
132 static void
|
|
|
133 init (void)
|
|
|
134 {
|
|
|
135 const char *active_wait = getenv (OFFLOAD_ACTIVE_WAIT_ENV);
|
|
|
136
|
|
|
137 /* Disable active wait by default to avoid useless CPU usage. */
|
|
|
138 if (!active_wait)
|
|
|
139 setenv (OFFLOAD_ACTIVE_WAIT_ENV, "0", 0);
|
|
|
140
|
|
|
141 address_table = new ImgDevAddrMap;
|
|
|
142 image_descriptors = new ImgDescMap;
|
|
|
143 num_devices = _Offload_number_of_devices ();
|
|
|
144 }
|
|
|
145
|
|
|
146 extern "C" const char *
|
|
|
147 GOMP_OFFLOAD_get_name (void)
|
|
|
148 {
|
|
|
149 const char *res = "intelmic";
|
|
|
150 TRACE ("(): return %s", res);
|
|
|
151 return res;
|
|
|
152 }
|
|
|
153
|
|
|
154 extern "C" unsigned int
|
|
|
155 GOMP_OFFLOAD_get_caps (void)
|
|
|
156 {
|
|
|
157 unsigned int res = GOMP_OFFLOAD_CAP_OPENMP_400;
|
|
|
158 TRACE ("(): return %x", res);
|
|
|
159 return res;
|
|
|
160 }
|
|
|
161
|
|
|
162 extern "C" int
|
|
|
163 GOMP_OFFLOAD_get_type (void)
|
|
|
164 {
|
|
|
165 enum offload_target_type res = OFFLOAD_TARGET_TYPE_INTEL_MIC;
|
|
|
166 TRACE ("(): return %d", res);
|
|
|
167 return res;
|
|
|
168 }
|
|
|
169
|
|
|
170 extern "C" int
|
|
|
171 GOMP_OFFLOAD_get_num_devices (void)
|
|
|
172 {
|
|
|
173 TRACE ("(): return %d", num_devices);
|
|
|
174 return num_devices;
|
|
|
175 }
|
|
|
176
|
|
|
177 static bool
|
|
|
178 offload (const char *file, uint64_t line, int device, const char *name,
|
|
|
179 int num_vars, VarDesc *vars, const void **async_data)
|
|
|
180 {
|
|
|
181 OFFLOAD ofld = __offload_target_acquire1 (&device, file, line);
|
|
|
182 if (ofld)
|
|
|
183 {
|
|
|
184 if (async_data == NULL)
|
|
|
185 return __offload_offload1 (ofld, name, 0, num_vars, vars, NULL, 0,
|
|
|
186 NULL, NULL);
|
|
|
187 else
|
|
|
188 {
|
|
|
189 OffloadFlags flags;
|
|
|
190 flags.flags = 0;
|
|
|
191 flags.bits.omp_async = 1;
|
|
|
192 return __offload_offload3 (ofld, name, 0, num_vars, vars, NULL, 0,
|
|
|
193 NULL, async_data, 0, NULL, flags, NULL);
|
|
|
194 }
|
|
|
195 }
|
|
|
196 else
|
|
|
197 {
|
|
|
198 GOMP_PLUGIN_error ("%s:%d: Offload target acquire failed\n", file, line);
|
|
|
199 return false;
|
|
|
200 }
|
|
|
201 }
|
|
|
202
|
|
|
203 static void
|
|
|
204 register_main_image ()
|
|
|
205 {
|
|
|
206 /* Do not check the return value, because old versions of liboffloadmic did
|
|
|
207 not have return values. */
|
|
|
208 __offload_register_image (&main_target_image);
|
|
|
209
|
|
|
210 /* liboffloadmic will call GOMP_PLUGIN_target_task_completion when
|
|
|
211 asynchronous task on target is completed. */
|
|
|
212 __offload_register_task_callback (GOMP_PLUGIN_target_task_completion);
|
|
|
213 }
|
|
|
214
|
|
|
215 /* liboffloadmic loads and runs offload_target_main on all available devices
|
|
|
216 during a first call to offload (). */
|
|
|
217 extern "C" bool
|
|
|
218 GOMP_OFFLOAD_init_device (int device)
|
|
|
219 {
|
|
|
220 TRACE ("(device = %d)", device);
|
|
|
221 pthread_once (&main_image_is_registered, register_main_image);
|
|
|
222 return offload (__FILE__, __LINE__, device, "__offload_target_init_proc", 0,
|
|
|
223 NULL, NULL);
|
|
|
224 }
|
|
|
225
|
|
|
226 extern "C" bool
|
|
|
227 GOMP_OFFLOAD_fini_device (int device)
|
|
|
228 {
|
|
|
229 TRACE ("(device = %d)", device);
|
|
|
230
|
|
|
231 /* liboffloadmic will finalize target processes on all available devices. */
|
|
|
232 __offload_unregister_image (&main_target_image);
|
|
|
233 return true;
|
|
|
234 }
|
|
|
235
|
|
|
236 static bool
|
|
|
237 get_target_table (int device, int &num_funcs, int &num_vars, void **&table)
|
|
|
238 {
|
|
|
239 VarDesc vd1[2] = { vd_tgt2host, vd_tgt2host };
|
|
|
240 vd1[0].ptr = &num_funcs;
|
|
|
241 vd1[0].size = sizeof (num_funcs);
|
|
|
242 vd1[1].ptr = &num_vars;
|
|
|
243 vd1[1].size = sizeof (num_vars);
|
|
|
244
|
|
|
245 if (!offload (__FILE__, __LINE__, device, "__offload_target_table_p1", 2,
|
|
|
246 vd1, NULL))
|
|
|
247 return false;
|
|
|
248
|
|
|
249 int table_size = num_funcs + 2 * num_vars;
|
|
|
250 if (table_size > 0)
|
|
|
251 {
|
|
|
252 table = new void * [table_size];
|
|
|
253
|
|
|
254 VarDesc vd2;
|
|
|
255 vd2 = vd_tgt2host;
|
|
|
256 vd2.ptr = table;
|
|
|
257 vd2.size = table_size * sizeof (void *);
|
|
|
258
|
|
|
259 return offload (__FILE__, __LINE__, device, "__offload_target_table_p2",
|
|
|
260 1, &vd2, NULL);
|
|
|
261 }
|
|
|
262 return true;
|
|
|
263 }
|
|
|
264
|
|
|
265 /* Offload TARGET_IMAGE to all available devices and fill address_table with
|
|
|
266 corresponding target addresses. */
|
|
|
267
|
|
|
268 static bool
|
|
|
269 offload_image (const void *target_image)
|
|
|
270 {
|
|
|
271 void *image_start = ((void **) target_image)[0];
|
|
|
272 void *image_end = ((void **) target_image)[1];
|
|
|
273
|
|
|
274 TRACE ("(target_image = %p { %p, %p })",
|
|
|
275 target_image, image_start, image_end);
|
|
|
276
|
|
|
277 int64_t image_size = (uintptr_t) image_end - (uintptr_t) image_start;
|
|
|
278 TargetImageDesc *image = (TargetImageDesc *) malloc (offsetof (TargetImageDesc, data)
|
|
|
279 + image_size);
|
|
|
280 if (!image)
|
|
|
281 {
|
|
|
282 GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__);
|
|
|
283 return false;
|
|
|
284 }
|
|
|
285
|
|
|
286 image->size = image_size;
|
|
|
287 sprintf (image->name, "lib%010d.so", num_images++);
|
|
|
288 memcpy (image->data, image_start, image->size);
|
|
|
289
|
|
|
290 TRACE ("() __offload_register_image %s { %p, %d }",
|
|
|
291 image->name, image_start, image->size);
|
|
|
292 /* Do not check the return value, because old versions of liboffloadmic did
|
|
|
293 not have return values. */
|
|
|
294 __offload_register_image (image);
|
|
|
295
|
|
|
296 /* Receive tables for target_image from all devices. */
|
|
|
297 DevAddrVect dev_table;
|
|
|
298 bool ret = true;
|
|
|
299 for (int dev = 0; dev < num_devices; dev++)
|
|
|
300 {
|
|
|
301 int num_funcs = 0;
|
|
|
302 int num_vars = 0;
|
|
|
303 void **table = NULL;
|
|
|
304
|
|
|
305 ret &= get_target_table (dev, num_funcs, num_vars, table);
|
|
|
306
|
|
|
307 AddrVect curr_dev_table;
|
|
|
308
|
|
|
309 for (int i = 0; i < num_funcs; i++)
|
|
|
310 {
|
|
|
311 addr_pair tgt_addr;
|
|
|
312 tgt_addr.start = (uintptr_t) table[i];
|
|
|
313 tgt_addr.end = tgt_addr.start + 1;
|
|
|
314 TRACE ("() func %d:\t0x%llx..0x%llx", i,
|
|
|
315 tgt_addr.start, tgt_addr.end);
|
|
|
316 curr_dev_table.push_back (tgt_addr);
|
|
|
317 }
|
|
|
318
|
|
|
319 for (int i = 0; i < num_vars; i++)
|
|
|
320 {
|
|
|
321 addr_pair tgt_addr;
|
|
|
322 tgt_addr.start = (uintptr_t) table[num_funcs+i*2];
|
|
|
323 tgt_addr.end = tgt_addr.start + (uintptr_t) table[num_funcs+i*2+1];
|
|
|
324 TRACE ("() var %d:\t0x%llx..0x%llx", i, tgt_addr.start, tgt_addr.end);
|
|
|
325 curr_dev_table.push_back (tgt_addr);
|
|
|
326 }
|
|
|
327
|
|
|
328 dev_table.push_back (curr_dev_table);
|
|
|
329 delete [] table;
|
|
|
330 }
|
|
|
331
|
|
|
332 address_table->insert (std::make_pair (target_image, dev_table));
|
|
|
333 image_descriptors->insert (std::make_pair (target_image, image));
|
|
|
334 return ret;
|
|
|
335 }
|
|
|
336
|
|
|
337 /* Return the libgomp version number we're compatible with. There is
|
|
|
338 no requirement for cross-version compatibility. */
|
|
|
339
|
|
|
340 extern "C" unsigned
|
|
|
341 GOMP_OFFLOAD_version (void)
|
|
|
342 {
|
|
|
343 return GOMP_VERSION;
|
|
|
344 }
|
|
|
345
|
|
|
346 extern "C" int
|
|
|
347 GOMP_OFFLOAD_load_image (int device, const unsigned version,
|
|
|
348 const void *target_image, addr_pair **result)
|
|
|
349 {
|
|
|
350 TRACE ("(device = %d, target_image = %p)", device, target_image);
|
|
|
351
|
|
|
352 if (GOMP_VERSION_DEV (version) > GOMP_VERSION_INTEL_MIC)
|
|
|
353 {
|
|
|
354 GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin"
|
|
|
355 " (expected %u, received %u)",
|
|
|
356 GOMP_VERSION_INTEL_MIC, GOMP_VERSION_DEV (version));
|
|
|
357 return -1;
|
|
|
358 }
|
|
|
359
|
|
|
360 /* If target_image is already present in address_table, then there is no need
|
|
|
361 to offload it. */
|
|
|
362 if (address_table->count (target_image) == 0)
|
|
|
363 {
|
|
|
364 /* If fail, return -1 as error code. */
|
|
|
365 if (!offload_image (target_image))
|
|
|
366 return -1;
|
|
|
367 }
|
|
|
368
|
|
|
369 AddrVect *curr_dev_table = &(*address_table)[target_image][device];
|
|
|
370 int table_size = curr_dev_table->size ();
|
|
|
371 addr_pair *table = (addr_pair *) malloc (table_size * sizeof (addr_pair));
|
|
|
372 if (table == NULL)
|
|
|
373 {
|
|
|
374 GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__);
|
|
|
375 return -1;
|
|
|
376 }
|
|
|
377
|
|
|
378 std::copy (curr_dev_table->begin (), curr_dev_table->end (), table);
|
|
|
379 *result = table;
|
|
|
380 return table_size;
|
|
|
381 }
|
|
|
382
|
|
|
383 extern "C" bool
|
|
|
384 GOMP_OFFLOAD_unload_image (int device, unsigned version,
|
|
|
385 const void *target_image)
|
|
|
386 {
|
|
|
387 if (GOMP_VERSION_DEV (version) > GOMP_VERSION_INTEL_MIC)
|
|
|
388 {
|
|
|
389 GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin"
|
|
|
390 " (expected %u, received %u)",
|
|
|
391 GOMP_VERSION_INTEL_MIC, GOMP_VERSION_DEV (version));
|
|
|
392 return false;
|
|
|
393 }
|
|
|
394
|
|
|
395 TRACE ("(device = %d, target_image = %p)", device, target_image);
|
|
|
396
|
|
|
397 /* liboffloadmic unloads the image from all available devices. */
|
|
|
398 if (image_descriptors->count (target_image) > 0)
|
|
|
399 {
|
|
|
400 TargetImageDesc *image_desc = (*image_descriptors)[target_image];
|
|
|
401 __offload_unregister_image (image_desc);
|
|
|
402 free (image_desc);
|
|
|
403
|
|
|
404 address_table->erase (target_image);
|
|
|
405 image_descriptors->erase (target_image);
|
|
|
406 }
|
|
|
407 return true;
|
|
|
408 }
|
|
|
409
|
|
|
410 extern "C" void *
|
|
|
411 GOMP_OFFLOAD_alloc (int device, size_t size)
|
|
|
412 {
|
|
|
413 TRACE ("(device = %d, size = %d)", device, size);
|
|
|
414
|
|
|
415 void *tgt_ptr;
|
|
|
416 VarDesc vd[2] = { vd_host2tgt, vd_tgt2host };
|
|
|
417 vd[0].ptr = &size;
|
|
|
418 vd[0].size = sizeof (size);
|
|
|
419 vd[1].ptr = &tgt_ptr;
|
|
|
420 vd[1].size = sizeof (void *);
|
|
|
421
|
|
|
422 if (!offload (__FILE__, __LINE__, device, "__offload_target_alloc", 2,
|
|
|
423 vd, NULL))
|
|
|
424 return NULL;
|
|
|
425
|
|
|
426 return tgt_ptr;
|
|
|
427 }
|
|
|
428
|
|
|
429 extern "C" bool
|
|
|
430 GOMP_OFFLOAD_free (int device, void *tgt_ptr)
|
|
|
431 {
|
|
|
432 TRACE ("(device = %d, tgt_ptr = %p)", device, tgt_ptr);
|
|
|
433
|
|
|
434 VarDesc vd = vd_host2tgt;
|
|
|
435 vd.ptr = &tgt_ptr;
|
|
|
436 vd.size = sizeof (void *);
|
|
|
437
|
|
|
438 return offload (__FILE__, __LINE__, device, "__offload_target_free", 1,
|
|
|
439 &vd, NULL);
|
|
|
440 }
|
|
|
441
|
|
|
442 extern "C" bool
|
|
|
443 GOMP_OFFLOAD_host2dev (int device, void *tgt_ptr, const void *host_ptr,
|
|
|
444 size_t size)
|
|
|
445 {
|
|
|
446 TRACE ("(device = %d, tgt_ptr = %p, host_ptr = %p, size = %d)",
|
|
|
447 device, tgt_ptr, host_ptr, size);
|
|
|
448 if (!size)
|
|
|
449 return true;
|
|
|
450
|
|
|
451 VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
|
|
|
452 vd1[0].ptr = &tgt_ptr;
|
|
|
453 vd1[0].size = sizeof (void *);
|
|
|
454 vd1[1].ptr = &size;
|
|
|
455 vd1[1].size = sizeof (size);
|
|
|
456
|
|
|
457 if (!offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p1", 2,
|
|
|
458 vd1, NULL))
|
|
|
459 return false;
|
|
|
460
|
|
|
461 VarDesc vd2 = vd_host2tgt;
|
|
|
462 vd2.ptr = (void *) host_ptr;
|
|
|
463 vd2.size = size;
|
|
|
464
|
|
|
465 return offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p2", 1,
|
|
|
466 &vd2, NULL);
|
|
|
467 }
|
|
|
468
|
|
|
469 extern "C" bool
|
|
|
470 GOMP_OFFLOAD_dev2host (int device, void *host_ptr, const void *tgt_ptr,
|
|
|
471 size_t size)
|
|
|
472 {
|
|
|
473 TRACE ("(device = %d, host_ptr = %p, tgt_ptr = %p, size = %d)",
|
|
|
474 device, host_ptr, tgt_ptr, size);
|
|
|
475 if (!size)
|
|
|
476 return true;
|
|
|
477
|
|
|
478 VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
|
|
|
479 vd1[0].ptr = &tgt_ptr;
|
|
|
480 vd1[0].size = sizeof (void *);
|
|
|
481 vd1[1].ptr = &size;
|
|
|
482 vd1[1].size = sizeof (size);
|
|
|
483
|
|
|
484 if (!offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p1", 2,
|
|
|
485 vd1, NULL))
|
|
|
486 return false;
|
|
|
487
|
|
|
488 VarDesc vd2 = vd_tgt2host;
|
|
|
489 vd2.ptr = (void *) host_ptr;
|
|
|
490 vd2.size = size;
|
|
|
491
|
|
|
492 return offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p2", 1,
|
|
|
493 &vd2, NULL);
|
|
|
494 }
|
|
|
495
|
|
|
496 extern "C" bool
|
|
|
497 GOMP_OFFLOAD_dev2dev (int device, void *dst_ptr, const void *src_ptr,
|
|
|
498 size_t size)
|
|
|
499 {
|
|
|
500 TRACE ("(device = %d, dst_ptr = %p, src_ptr = %p, size = %d)",
|
|
|
501 device, dst_ptr, src_ptr, size);
|
|
|
502 if (!size)
|
|
|
503 return true;
|
|
|
504
|
|
|
505 VarDesc vd[3] = { vd_host2tgt, vd_host2tgt, vd_host2tgt };
|
|
|
506 vd[0].ptr = &dst_ptr;
|
|
|
507 vd[0].size = sizeof (void *);
|
|
|
508 vd[1].ptr = &src_ptr;
|
|
|
509 vd[1].size = sizeof (void *);
|
|
|
510 vd[2].ptr = &size;
|
|
|
511 vd[2].size = sizeof (size);
|
|
|
512
|
|
|
513 return offload (__FILE__, __LINE__, device, "__offload_target_tgt2tgt", 3,
|
|
|
514 vd, NULL);
|
|
|
515 }
|
|
|
516
|
|
|
517 extern "C" void
|
|
|
518 GOMP_OFFLOAD_async_run (int device, void *tgt_fn, void *tgt_vars,
|
|
|
519 void **, void *async_data)
|
|
|
520 {
|
|
|
521 TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p, async_data = %p)", device,
|
|
|
522 tgt_fn, tgt_vars, async_data);
|
|
|
523
|
|
|
524 VarDesc vd[2] = { vd_host2tgt, vd_host2tgt };
|
|
|
525 vd[0].ptr = &tgt_fn;
|
|
|
526 vd[0].size = sizeof (void *);
|
|
|
527 vd[1].ptr = &tgt_vars;
|
|
|
528 vd[1].size = sizeof (void *);
|
|
|
529
|
|
|
530 offload (__FILE__, __LINE__, device, "__offload_target_run", 2, vd,
|
|
|
531 (const void **) async_data);
|
|
|
532 }
|
|
|
533
|
|
|
534 extern "C" void
|
|
|
535 GOMP_OFFLOAD_run (int device, void *tgt_fn, void *tgt_vars, void **)
|
|
|
536 {
|
|
|
537 TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p)", device, tgt_fn, tgt_vars);
|
|
|
538
|
|
|
539 GOMP_OFFLOAD_async_run (device, tgt_fn, tgt_vars, NULL, NULL);
|
|
|
540 }
|
