]>
Commit | Line | Data |
---|---|---|
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 | extern "C" union gomp_device_property_value | |
178 | GOMP_OFFLOAD_get_property (int n, int prop) | |
179 | { | |
180 | union gomp_device_property_value nullval = { .val = 0 }; | |
181 | ||
182 | if (n >= num_devices) | |
183 | { | |
184 | GOMP_PLUGIN_error | |
185 | ("Request for a property of a non-existing Intel MIC device %i", n); | |
186 | return nullval; | |
187 | } | |
188 | ||
189 | switch (prop) | |
190 | { | |
191 | case GOMP_DEVICE_PROPERTY_VENDOR: | |
192 | return (union gomp_device_property_value) { .ptr = "Intel" }; | |
193 | default: | |
194 | return nullval; | |
195 | } | |
196 | } | |
197 | ||
198 | static bool | |
199 | offload (const char *file, uint64_t line, int device, const char *name, | |
200 | int num_vars, VarDesc *vars, const void **async_data) | |
201 | { | |
202 | OFFLOAD ofld = __offload_target_acquire1 (&device, file, line); | |
203 | if (ofld) | |
204 | { | |
205 | if (async_data == NULL) | |
206 | return __offload_offload1 (ofld, name, 0, num_vars, vars, NULL, 0, | |
207 | NULL, NULL); | |
208 | else | |
209 | { | |
210 | OffloadFlags flags; | |
211 | flags.flags = 0; | |
212 | flags.bits.omp_async = 1; | |
213 | return __offload_offload3 (ofld, name, 0, num_vars, vars, NULL, 0, | |
214 | NULL, async_data, 0, NULL, flags, NULL); | |
215 | } | |
216 | } | |
217 | else | |
218 | { | |
219 | GOMP_PLUGIN_error ("%s:%d: Offload target acquire failed\n", file, line); | |
220 | return false; | |
221 | } | |
222 | } | |
223 | ||
224 | static void | |
225 | register_main_image () | |
226 | { | |
227 | /* Do not check the return value, because old versions of liboffloadmic did | |
228 | not have return values. */ | |
229 | __offload_register_image (&main_target_image); | |
230 | ||
231 | /* liboffloadmic will call GOMP_PLUGIN_target_task_completion when | |
232 | asynchronous task on target is completed. */ | |
233 | __offload_register_task_callback (GOMP_PLUGIN_target_task_completion); | |
234 | } | |
235 | ||
236 | /* liboffloadmic loads and runs offload_target_main on all available devices | |
237 | during a first call to offload (). */ | |
238 | extern "C" bool | |
239 | GOMP_OFFLOAD_init_device (int device) | |
240 | { | |
241 | TRACE ("(device = %d)", device); | |
242 | pthread_once (&main_image_is_registered, register_main_image); | |
243 | return offload (__FILE__, __LINE__, device, "__offload_target_init_proc", 0, | |
244 | NULL, NULL); | |
245 | } | |
246 | ||
247 | extern "C" bool | |
248 | GOMP_OFFLOAD_fini_device (int device) | |
249 | { | |
250 | TRACE ("(device = %d)", device); | |
251 | ||
252 | /* liboffloadmic will finalize target processes on all available devices. */ | |
253 | __offload_unregister_image (&main_target_image); | |
254 | return true; | |
255 | } | |
256 | ||
257 | static bool | |
258 | get_target_table (int device, int &num_funcs, int &num_vars, void **&table) | |
259 | { | |
260 | VarDesc vd1[2] = { vd_tgt2host, vd_tgt2host }; | |
261 | vd1[0].ptr = &num_funcs; | |
262 | vd1[0].size = sizeof (num_funcs); | |
263 | vd1[1].ptr = &num_vars; | |
264 | vd1[1].size = sizeof (num_vars); | |
265 | ||
266 | if (!offload (__FILE__, __LINE__, device, "__offload_target_table_p1", 2, | |
267 | vd1, NULL)) | |
268 | return false; | |
269 | ||
270 | int table_size = num_funcs + 2 * num_vars; | |
271 | if (table_size > 0) | |
272 | { | |
273 | table = new void * [table_size]; | |
274 | ||
275 | VarDesc vd2; | |
276 | vd2 = vd_tgt2host; | |
277 | vd2.ptr = table; | |
278 | vd2.size = table_size * sizeof (void *); | |
279 | ||
280 | return offload (__FILE__, __LINE__, device, "__offload_target_table_p2", | |
281 | 1, &vd2, NULL); | |
282 | } | |
283 | return true; | |
284 | } | |
285 | ||
286 | /* Offload TARGET_IMAGE to all available devices and fill address_table with | |
287 | corresponding target addresses. */ | |
288 | ||
289 | static bool | |
290 | offload_image (const void *target_image) | |
291 | { | |
292 | void *image_start = ((void **) target_image)[0]; | |
293 | void *image_end = ((void **) target_image)[1]; | |
294 | ||
295 | TRACE ("(target_image = %p { %p, %p })", | |
296 | target_image, image_start, image_end); | |
297 | ||
298 | int64_t image_size = (uintptr_t) image_end - (uintptr_t) image_start; | |
299 | TargetImageDesc *image = (TargetImageDesc *) malloc (offsetof (TargetImageDesc, data) | |
300 | + image_size); | |
301 | if (!image) | |
302 | { | |
303 | GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__); | |
304 | return false; | |
305 | } | |
306 | ||
307 | image->size = image_size; | |
308 | sprintf (image->name, "lib%010d.so", num_images++); | |
309 | memcpy (image->data, image_start, image->size); | |
310 | ||
311 | TRACE ("() __offload_register_image %s { %p, %d }", | |
312 | image->name, image_start, image->size); | |
313 | /* Do not check the return value, because old versions of liboffloadmic did | |
314 | not have return values. */ | |
315 | __offload_register_image (image); | |
316 | ||
317 | /* Receive tables for target_image from all devices. */ | |
318 | DevAddrVect dev_table; | |
319 | bool ret = true; | |
320 | for (int dev = 0; dev < num_devices; dev++) | |
321 | { | |
322 | int num_funcs = 0; | |
323 | int num_vars = 0; | |
324 | void **table = NULL; | |
325 | ||
326 | ret &= get_target_table (dev, num_funcs, num_vars, table); | |
327 | ||
328 | AddrVect curr_dev_table; | |
329 | ||
330 | for (int i = 0; i < num_funcs; i++) | |
331 | { | |
332 | addr_pair tgt_addr; | |
333 | tgt_addr.start = (uintptr_t) table[i]; | |
334 | tgt_addr.end = tgt_addr.start + 1; | |
335 | TRACE ("() func %d:\t0x%llx..0x%llx", i, | |
336 | tgt_addr.start, tgt_addr.end); | |
337 | curr_dev_table.push_back (tgt_addr); | |
338 | } | |
339 | ||
340 | for (int i = 0; i < num_vars; i++) | |
341 | { | |
342 | addr_pair tgt_addr; | |
343 | tgt_addr.start = (uintptr_t) table[num_funcs+i*2]; | |
344 | tgt_addr.end = tgt_addr.start + (uintptr_t) table[num_funcs+i*2+1]; | |
345 | TRACE ("() var %d:\t0x%llx..0x%llx", i, tgt_addr.start, tgt_addr.end); | |
346 | curr_dev_table.push_back (tgt_addr); | |
347 | } | |
348 | ||
349 | dev_table.push_back (curr_dev_table); | |
350 | delete [] table; | |
351 | } | |
352 | ||
353 | address_table->insert (std::make_pair (target_image, dev_table)); | |
354 | image_descriptors->insert (std::make_pair (target_image, image)); | |
355 | return ret; | |
356 | } | |
357 | ||
358 | /* Return the libgomp version number we're compatible with. There is | |
359 | no requirement for cross-version compatibility. */ | |
360 | ||
361 | extern "C" unsigned | |
362 | GOMP_OFFLOAD_version (void) | |
363 | { | |
364 | return GOMP_VERSION; | |
365 | } | |
366 | ||
367 | extern "C" int | |
368 | GOMP_OFFLOAD_load_image (int device, const unsigned version, | |
369 | const void *target_image, addr_pair **result) | |
370 | { | |
371 | TRACE ("(device = %d, target_image = %p)", device, target_image); | |
372 | ||
373 | if (GOMP_VERSION_DEV (version) > GOMP_VERSION_INTEL_MIC) | |
374 | { | |
375 | GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin" | |
376 | " (expected %u, received %u)", | |
377 | GOMP_VERSION_INTEL_MIC, GOMP_VERSION_DEV (version)); | |
378 | return -1; | |
379 | } | |
380 | ||
381 | /* If target_image is already present in address_table, then there is no need | |
382 | to offload it. */ | |
383 | if (address_table->count (target_image) == 0) | |
384 | { | |
385 | /* If fail, return -1 as error code. */ | |
386 | if (!offload_image (target_image)) | |
387 | return -1; | |
388 | } | |
389 | ||
390 | AddrVect *curr_dev_table = &(*address_table)[target_image][device]; | |
391 | int table_size = curr_dev_table->size (); | |
392 | addr_pair *table = (addr_pair *) malloc (table_size * sizeof (addr_pair)); | |
393 | if (table == NULL) | |
394 | { | |
395 | GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__); | |
396 | return -1; | |
397 | } | |
398 | ||
399 | std::copy (curr_dev_table->begin (), curr_dev_table->end (), table); | |
400 | *result = table; | |
401 | return table_size; | |
402 | } | |
403 | ||
404 | extern "C" bool | |
405 | GOMP_OFFLOAD_unload_image (int device, unsigned version, | |
406 | const void *target_image) | |
407 | { | |
408 | if (GOMP_VERSION_DEV (version) > GOMP_VERSION_INTEL_MIC) | |
409 | { | |
410 | GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin" | |
411 | " (expected %u, received %u)", | |
412 | GOMP_VERSION_INTEL_MIC, GOMP_VERSION_DEV (version)); | |
413 | return false; | |
414 | } | |
415 | ||
416 | TRACE ("(device = %d, target_image = %p)", device, target_image); | |
417 | ||
418 | /* liboffloadmic unloads the image from all available devices. */ | |
419 | if (image_descriptors->count (target_image) > 0) | |
420 | { | |
421 | TargetImageDesc *image_desc = (*image_descriptors)[target_image]; | |
422 | __offload_unregister_image (image_desc); | |
423 | free (image_desc); | |
424 | ||
425 | address_table->erase (target_image); | |
426 | image_descriptors->erase (target_image); | |
427 | } | |
428 | return true; | |
429 | } | |
430 | ||
431 | extern "C" void * | |
432 | GOMP_OFFLOAD_alloc (int device, size_t size) | |
433 | { | |
434 | TRACE ("(device = %d, size = %d)", device, size); | |
435 | ||
436 | void *tgt_ptr; | |
437 | VarDesc vd[2] = { vd_host2tgt, vd_tgt2host }; | |
438 | vd[0].ptr = &size; | |
439 | vd[0].size = sizeof (size); | |
440 | vd[1].ptr = &tgt_ptr; | |
441 | vd[1].size = sizeof (void *); | |
442 | ||
443 | if (!offload (__FILE__, __LINE__, device, "__offload_target_alloc", 2, | |
444 | vd, NULL)) | |
445 | return NULL; | |
446 | ||
447 | return tgt_ptr; | |
448 | } | |
449 | ||
450 | extern "C" bool | |
451 | GOMP_OFFLOAD_free (int device, void *tgt_ptr) | |
452 | { | |
453 | TRACE ("(device = %d, tgt_ptr = %p)", device, tgt_ptr); | |
454 | ||
455 | VarDesc vd = vd_host2tgt; | |
456 | vd.ptr = &tgt_ptr; | |
457 | vd.size = sizeof (void *); | |
458 | ||
459 | return offload (__FILE__, __LINE__, device, "__offload_target_free", 1, | |
460 | &vd, NULL); | |
461 | } | |
462 | ||
463 | extern "C" bool | |
464 | GOMP_OFFLOAD_host2dev (int device, void *tgt_ptr, const void *host_ptr, | |
465 | size_t size) | |
466 | { | |
467 | TRACE ("(device = %d, tgt_ptr = %p, host_ptr = %p, size = %d)", | |
468 | device, tgt_ptr, host_ptr, size); | |
469 | if (!size) | |
470 | return true; | |
471 | ||
472 | VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt }; | |
473 | vd1[0].ptr = &tgt_ptr; | |
474 | vd1[0].size = sizeof (void *); | |
475 | vd1[1].ptr = &size; | |
476 | vd1[1].size = sizeof (size); | |
477 | ||
478 | if (!offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p1", 2, | |
479 | vd1, NULL)) | |
480 | return false; | |
481 | ||
482 | VarDesc vd2 = vd_host2tgt; | |
483 | vd2.ptr = (void *) host_ptr; | |
484 | vd2.size = size; | |
485 | ||
486 | return offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p2", 1, | |
487 | &vd2, NULL); | |
488 | } | |
489 | ||
490 | extern "C" bool | |
491 | GOMP_OFFLOAD_dev2host (int device, void *host_ptr, const void *tgt_ptr, | |
492 | size_t size) | |
493 | { | |
494 | TRACE ("(device = %d, host_ptr = %p, tgt_ptr = %p, size = %d)", | |
495 | device, host_ptr, tgt_ptr, size); | |
496 | if (!size) | |
497 | return true; | |
498 | ||
499 | VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt }; | |
500 | vd1[0].ptr = &tgt_ptr; | |
501 | vd1[0].size = sizeof (void *); | |
502 | vd1[1].ptr = &size; | |
503 | vd1[1].size = sizeof (size); | |
504 | ||
505 | if (!offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p1", 2, | |
506 | vd1, NULL)) | |
507 | return false; | |
508 | ||
509 | VarDesc vd2 = vd_tgt2host; | |
510 | vd2.ptr = (void *) host_ptr; | |
511 | vd2.size = size; | |
512 | ||
513 | return offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p2", 1, | |
514 | &vd2, NULL); | |
515 | } | |
516 | ||
517 | extern "C" bool | |
518 | GOMP_OFFLOAD_dev2dev (int device, void *dst_ptr, const void *src_ptr, | |
519 | size_t size) | |
520 | { | |
521 | TRACE ("(device = %d, dst_ptr = %p, src_ptr = %p, size = %d)", | |
522 | device, dst_ptr, src_ptr, size); | |
523 | if (!size) | |
524 | return true; | |
525 | ||
526 | VarDesc vd[3] = { vd_host2tgt, vd_host2tgt, vd_host2tgt }; | |
527 | vd[0].ptr = &dst_ptr; | |
528 | vd[0].size = sizeof (void *); | |
529 | vd[1].ptr = &src_ptr; | |
530 | vd[1].size = sizeof (void *); | |
531 | vd[2].ptr = &size; | |
532 | vd[2].size = sizeof (size); | |
533 | ||
534 | return offload (__FILE__, __LINE__, device, "__offload_target_tgt2tgt", 3, | |
535 | vd, NULL); | |
536 | } | |
537 | ||
538 | extern "C" void | |
539 | GOMP_OFFLOAD_async_run (int device, void *tgt_fn, void *tgt_vars, | |
540 | void **, void *async_data) | |
541 | { | |
542 | TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p, async_data = %p)", device, | |
543 | tgt_fn, tgt_vars, async_data); | |
544 | ||
545 | VarDesc vd[2] = { vd_host2tgt, vd_host2tgt }; | |
546 | vd[0].ptr = &tgt_fn; | |
547 | vd[0].size = sizeof (void *); | |
548 | vd[1].ptr = &tgt_vars; | |
549 | vd[1].size = sizeof (void *); | |
550 | ||
551 | offload (__FILE__, __LINE__, device, "__offload_target_run", 2, vd, | |
552 | (const void **) async_data); | |
553 | } | |
554 | ||
555 | extern "C" void | |
556 | GOMP_OFFLOAD_run (int device, void *tgt_fn, void *tgt_vars, void **) | |
557 | { | |
558 | TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p)", device, tgt_fn, tgt_vars); | |
559 | ||
560 | GOMP_OFFLOAD_async_run (device, tgt_fn, tgt_vars, NULL, NULL); | |
561 | } |