1 /* Plugin for offload execution on Intel MIC devices.
3 Copyright (C) 2014-2015 Free Software Foundation, Inc.
5 Contributed by Ilya Verbin <ilya.verbin@intel.com>.
7 This file is part of the GNU Offloading and Multi Processing Library
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)
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
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.
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/>. */
29 /* Host side part of a libgomp plugin. */
38 #include "libgomp-plugin.h"
39 #include "compiler_if_host.h"
40 #include "main_target_image.h"
41 #include "gomp-constants.h"
43 #define LD_LIBRARY_PATH_ENV "LD_LIBRARY_PATH"
44 #define MIC_LD_LIBRARY_PATH_ENV "MIC_LD_LIBRARY_PATH"
45 #define OFFLOAD_ACTIVE_WAIT_ENV "OFFLOAD_ACTIVE_WAIT"
50 fprintf (stderr, "HOST:\t%s:%s ", __FILE__, __FUNCTION__); \
51 fprintf (stderr, __VA_ARGS__); \
52 fprintf (stderr, "\n"); \
59 /* Start/end addresses of functions and global variables on a device. */
60 typedef std::vector
<addr_pair
> AddrVect
;
62 /* Addresses for one image and all devices. */
63 typedef std::vector
<AddrVect
> DevAddrVect
;
65 /* Addresses for all images and all devices. */
66 typedef std::map
<const void *, DevAddrVect
> ImgDevAddrMap
;
68 /* Image descriptor needed by __offload_[un]register_image. */
69 struct TargetImageDesc
{
71 /* 10 characters is enough for max int value. */
72 char name
[sizeof ("lib0000000000.so")];
76 /* Image descriptors, indexed by a pointer obtained from libgomp. */
77 typedef std::map
<const void *, TargetImageDesc
*> ImgDescMap
;
80 /* Total number of available devices. */
81 static int num_devices
;
83 /* Total number of shared libraries with offloading to Intel MIC. */
84 static int num_images
;
86 /* Two dimensional array: one key is a pointer to image,
87 second key is number of device. Contains a vector of pointer pairs. */
88 static ImgDevAddrMap
*address_table
;
90 /* Descriptors of all images, registered in liboffloadmic. */
91 static ImgDescMap
*image_descriptors
;
93 /* Thread-safe registration of the main image. */
94 static pthread_once_t main_image_is_registered
= PTHREAD_ONCE_INIT
;
96 static VarDesc vd_host2tgt
= {
97 { 1, 1 }, /* dst, src */
98 { 1, 0 }, /* in, out */
103 { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
104 is_stack_buf, sink_addr, alloc_disp,
105 is_noncont_src, is_noncont_dst */
114 static VarDesc vd_tgt2host
= {
115 { 1, 1 }, /* dst, src */
116 { 0, 1 }, /* in, out */
121 { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
122 is_stack_buf, sink_addr, alloc_disp,
123 is_noncont_src, is_noncont_dst */
133 __attribute__((constructor
))
137 const char *ld_lib_path
= getenv (LD_LIBRARY_PATH_ENV
);
138 const char *mic_lib_path
= getenv (MIC_LD_LIBRARY_PATH_ENV
);
139 const char *active_wait
= getenv (OFFLOAD_ACTIVE_WAIT_ENV
);
141 /* Disable active wait by default to avoid useless CPU usage. */
143 setenv (OFFLOAD_ACTIVE_WAIT_ENV
, "0", 0);
148 /* Add path specified in LD_LIBRARY_PATH to MIC_LD_LIBRARY_PATH, which is
149 required by liboffloadmic. */
151 setenv (MIC_LD_LIBRARY_PATH_ENV
, ld_lib_path
, 1);
154 size_t len
= strlen (mic_lib_path
) + strlen (ld_lib_path
) + 2;
155 bool use_alloca
= len
<= 2048;
156 char *mic_lib_path_new
= (char *) (use_alloca
? alloca (len
)
158 if (!mic_lib_path_new
)
160 fprintf (stderr
, "%s: Can't allocate memory\n", __FILE__
);
164 sprintf (mic_lib_path_new
, "%s:%s", mic_lib_path
, ld_lib_path
);
165 setenv (MIC_LD_LIBRARY_PATH_ENV
, mic_lib_path_new
, 1);
168 free (mic_lib_path_new
);
172 address_table
= new ImgDevAddrMap
;
173 image_descriptors
= new ImgDescMap
;
174 num_devices
= _Offload_number_of_devices ();
177 extern "C" const char *
178 GOMP_OFFLOAD_get_name (void)
180 const char *res
= "intelmic";
181 TRACE ("(): return %s", res
);
185 extern "C" unsigned int
186 GOMP_OFFLOAD_get_caps (void)
188 unsigned int res
= GOMP_OFFLOAD_CAP_OPENMP_400
;
189 TRACE ("(): return %x", res
);
193 extern "C" enum offload_target_type
194 GOMP_OFFLOAD_get_type (void)
196 enum offload_target_type res
= OFFLOAD_TARGET_TYPE_INTEL_MIC
;
197 TRACE ("(): return %d", res
);
202 GOMP_OFFLOAD_get_num_devices (void)
204 TRACE ("(): return %d", num_devices
);
209 offload (const char *file
, uint64_t line
, int device
, const char *name
,
210 int num_vars
, VarDesc
*vars
, const void **async_data
)
212 OFFLOAD ofld
= __offload_target_acquire1 (&device
, file
, line
);
215 if (async_data
== NULL
)
216 return __offload_offload1 (ofld
, name
, 0, num_vars
, vars
, NULL
, 0,
222 flags
.bits
.omp_async
= 1;
223 return __offload_offload3 (ofld
, name
, 0, num_vars
, vars
, NULL
, 0,
224 NULL
, async_data
, 0, NULL
, flags
, NULL
);
229 GOMP_PLUGIN_error ("%s:%d: Offload target acquire failed\n", file
, line
);
235 register_main_image ()
237 /* Do not check the return value, because old versions of liboffloadmic did
238 not have return values. */
239 __offload_register_image (&main_target_image
);
241 /* liboffloadmic will call GOMP_PLUGIN_target_task_completion when
242 asynchronous task on target is completed. */
243 __offload_register_task_callback (GOMP_PLUGIN_target_task_completion
);
246 /* liboffloadmic loads and runs offload_target_main on all available devices
247 during a first call to offload (). */
249 GOMP_OFFLOAD_init_device (int device
)
251 TRACE ("(device = %d)", device
);
252 pthread_once (&main_image_is_registered
, register_main_image
);
253 return offload (__FILE__
, __LINE__
, device
, "__offload_target_init_proc", 0,
258 GOMP_OFFLOAD_fini_device (int device
)
260 TRACE ("(device = %d)", device
);
262 /* liboffloadmic will finalize target processes on all available devices. */
263 __offload_unregister_image (&main_target_image
);
268 get_target_table (int device
, int &num_funcs
, int &num_vars
, void **&table
)
270 VarDesc vd1
[2] = { vd_tgt2host
, vd_tgt2host
};
271 vd1
[0].ptr
= &num_funcs
;
272 vd1
[0].size
= sizeof (num_funcs
);
273 vd1
[1].ptr
= &num_vars
;
274 vd1
[1].size
= sizeof (num_vars
);
276 if (!offload (__FILE__
, __LINE__
, device
, "__offload_target_table_p1", 2,
280 int table_size
= num_funcs
+ 2 * num_vars
;
283 table
= new void * [table_size
];
288 vd2
.size
= table_size
* sizeof (void *);
290 return offload (__FILE__
, __LINE__
, device
, "__offload_target_table_p2",
296 /* Offload TARGET_IMAGE to all available devices and fill address_table with
297 corresponding target addresses. */
300 offload_image (const void *target_image
)
302 void *image_start
= ((void **) target_image
)[0];
303 void *image_end
= ((void **) target_image
)[1];
305 TRACE ("(target_image = %p { %p, %p })",
306 target_image
, image_start
, image_end
);
308 int64_t image_size
= (uintptr_t) image_end
- (uintptr_t) image_start
;
309 TargetImageDesc
*image
= (TargetImageDesc
*) malloc (offsetof (TargetImageDesc
, data
)
313 GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__
);
317 image
->size
= image_size
;
318 sprintf (image
->name
, "lib%010d.so", num_images
++);
319 memcpy (image
->data
, image_start
, image
->size
);
321 TRACE ("() __offload_register_image %s { %p, %d }",
322 image
->name
, image_start
, image
->size
);
323 /* Do not check the return value, because old versions of liboffloadmic did
324 not have return values. */
325 __offload_register_image (image
);
327 /* Receive tables for target_image from all devices. */
328 DevAddrVect dev_table
;
330 for (int dev
= 0; dev
< num_devices
; dev
++)
336 ret
&= get_target_table (dev
, num_funcs
, num_vars
, table
);
338 AddrVect curr_dev_table
;
340 for (int i
= 0; i
< num_funcs
; i
++)
343 tgt_addr
.start
= (uintptr_t) table
[i
];
344 tgt_addr
.end
= tgt_addr
.start
+ 1;
345 TRACE ("() func %d:\t0x%llx..0x%llx", i
,
346 tgt_addr
.start
, tgt_addr
.end
);
347 curr_dev_table
.push_back (tgt_addr
);
350 for (int i
= 0; i
< num_vars
; i
++)
353 tgt_addr
.start
= (uintptr_t) table
[num_funcs
+i
*2];
354 tgt_addr
.end
= tgt_addr
.start
+ (uintptr_t) table
[num_funcs
+i
*2+1];
355 TRACE ("() var %d:\t0x%llx..0x%llx", i
, tgt_addr
.start
, tgt_addr
.end
);
356 curr_dev_table
.push_back (tgt_addr
);
359 dev_table
.push_back (curr_dev_table
);
363 address_table
->insert (std::make_pair (target_image
, dev_table
));
364 image_descriptors
->insert (std::make_pair (target_image
, image
));
368 /* Return the libgomp version number we're compatible with. There is
369 no requirement for cross-version compatibility. */
372 GOMP_OFFLOAD_version (void)
378 GOMP_OFFLOAD_load_image (int device
, const unsigned version
,
379 void *target_image
, addr_pair
**result
)
381 TRACE ("(device = %d, target_image = %p)", device
, target_image
);
383 if (GOMP_VERSION_DEV (version
) > GOMP_VERSION_INTEL_MIC
)
385 GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin"
386 " (expected %u, received %u)",
387 GOMP_VERSION_INTEL_MIC
, GOMP_VERSION_DEV (version
));
391 /* If target_image is already present in address_table, then there is no need
393 if (address_table
->count (target_image
) == 0)
395 /* If fail, return -1 as error code. */
396 if (!offload_image (target_image
))
400 AddrVect
*curr_dev_table
= &(*address_table
)[target_image
][device
];
401 int table_size
= curr_dev_table
->size ();
402 addr_pair
*table
= (addr_pair
*) malloc (table_size
* sizeof (addr_pair
));
405 GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__
);
409 std::copy (curr_dev_table
->begin (), curr_dev_table
->end (), table
);
415 GOMP_OFFLOAD_unload_image (int device
, unsigned version
,
416 const void *target_image
)
418 if (GOMP_VERSION_DEV (version
) > GOMP_VERSION_INTEL_MIC
)
420 GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin"
421 " (expected %u, received %u)",
422 GOMP_VERSION_INTEL_MIC
, GOMP_VERSION_DEV (version
));
426 TRACE ("(device = %d, target_image = %p)", device
, target_image
);
428 /* liboffloadmic unloads the image from all available devices. */
429 if (image_descriptors
->count (target_image
) > 0)
431 TargetImageDesc
*image_desc
= (*image_descriptors
)[target_image
];
432 __offload_unregister_image (image_desc
);
435 address_table
->erase (target_image
);
436 image_descriptors
->erase (target_image
);
442 GOMP_OFFLOAD_alloc (int device
, size_t size
)
444 TRACE ("(device = %d, size = %d)", device
, size
);
447 VarDesc vd
[2] = { vd_host2tgt
, vd_tgt2host
};
449 vd
[0].size
= sizeof (size
);
450 vd
[1].ptr
= &tgt_ptr
;
451 vd
[1].size
= sizeof (void *);
453 if (!offload (__FILE__
, __LINE__
, device
, "__offload_target_alloc", 2,
461 GOMP_OFFLOAD_free (int device
, void *tgt_ptr
)
463 TRACE ("(device = %d, tgt_ptr = %p)", device
, tgt_ptr
);
465 VarDesc vd
= vd_host2tgt
;
467 vd
.size
= sizeof (void *);
469 return offload (__FILE__
, __LINE__
, device
, "__offload_target_free", 1,
474 GOMP_OFFLOAD_host2dev (int device
, void *tgt_ptr
, const void *host_ptr
,
477 TRACE ("(device = %d, tgt_ptr = %p, host_ptr = %p, size = %d)",
478 device
, tgt_ptr
, host_ptr
, size
);
482 VarDesc vd1
[2] = { vd_host2tgt
, vd_host2tgt
};
483 vd1
[0].ptr
= &tgt_ptr
;
484 vd1
[0].size
= sizeof (void *);
486 vd1
[1].size
= sizeof (size
);
488 if (!offload (__FILE__
, __LINE__
, device
, "__offload_target_host2tgt_p1", 2,
492 VarDesc vd2
= vd_host2tgt
;
493 vd2
.ptr
= (void *) host_ptr
;
496 return offload (__FILE__
, __LINE__
, device
, "__offload_target_host2tgt_p2", 1,
501 GOMP_OFFLOAD_dev2host (int device
, void *host_ptr
, const void *tgt_ptr
,
504 TRACE ("(device = %d, host_ptr = %p, tgt_ptr = %p, size = %d)",
505 device
, host_ptr
, tgt_ptr
, size
);
509 VarDesc vd1
[2] = { vd_host2tgt
, vd_host2tgt
};
510 vd1
[0].ptr
= &tgt_ptr
;
511 vd1
[0].size
= sizeof (void *);
513 vd1
[1].size
= sizeof (size
);
515 if (!offload (__FILE__
, __LINE__
, device
, "__offload_target_tgt2host_p1", 2,
519 VarDesc vd2
= vd_tgt2host
;
520 vd2
.ptr
= (void *) host_ptr
;
523 return offload (__FILE__
, __LINE__
, device
, "__offload_target_tgt2host_p2", 1,
528 GOMP_OFFLOAD_dev2dev (int device
, void *dst_ptr
, const void *src_ptr
,
531 TRACE ("(device = %d, dst_ptr = %p, src_ptr = %p, size = %d)",
532 device
, dst_ptr
, src_ptr
, size
);
536 VarDesc vd
[3] = { vd_host2tgt
, vd_host2tgt
, vd_host2tgt
};
537 vd
[0].ptr
= &dst_ptr
;
538 vd
[0].size
= sizeof (void *);
539 vd
[1].ptr
= &src_ptr
;
540 vd
[1].size
= sizeof (void *);
542 vd
[2].size
= sizeof (size
);
544 return offload (__FILE__
, __LINE__
, device
, "__offload_target_tgt2tgt", 3,
549 GOMP_OFFLOAD_async_run (int device
, void *tgt_fn
, void *tgt_vars
,
550 void **, void *async_data
)
552 TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p, async_data = %p)", device
,
553 tgt_fn
, tgt_vars
, async_data
);
555 VarDesc vd
[2] = { vd_host2tgt
, vd_host2tgt
};
557 vd
[0].size
= sizeof (void *);
558 vd
[1].ptr
= &tgt_vars
;
559 vd
[1].size
= sizeof (void *);
561 offload (__FILE__
, __LINE__
, device
, "__offload_target_run", 2, vd
,
562 (const void **) async_data
);
566 GOMP_OFFLOAD_run (int device
, void *tgt_fn
, void *tgt_vars
, void **)
568 TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p)", device
, tgt_fn
, tgt_vars
);
570 GOMP_OFFLOAD_async_run (device
, tgt_fn
, tgt_vars
, NULL
, NULL
);