123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540 |
- /* Plugin for offload execution on Intel MIC devices.
- Copyright (C) 2014-2016 Free Software Foundation, Inc.
- Contributed by Ilya Verbin <ilya.verbin@intel.com>.
- This file is part of the GNU Offloading and Multi Processing Library
- (libgomp).
- Libgomp is free software; you can redistribute it and/or modify it
- under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3, or (at your option)
- any later version.
- Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
- WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- more details.
- Under Section 7 of GPL version 3, you are granted additional
- permissions described in the GCC Runtime Library Exception, version
- 3.1, as published by the Free Software Foundation.
- You should have received a copy of the GNU General Public License and
- a copy of the GCC Runtime Library Exception along with this program;
- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
- <http://www.gnu.org/licenses/>. */
- /* Host side part of a libgomp plugin. */
- #include <stdint.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <utility>
- #include <vector>
- #include <map>
- #include "libgomp-plugin.h"
- #include "compiler_if_host.h"
- #include "main_target_image.h"
- #include "gomp-constants.h"
- #define OFFLOAD_ACTIVE_WAIT_ENV "OFFLOAD_ACTIVE_WAIT"
- #ifdef DEBUG
- #define TRACE(...) \
- { \
- fprintf (stderr, "HOST:\t%s:%s ", __FILE__, __FUNCTION__); \
- fprintf (stderr, __VA_ARGS__); \
- fprintf (stderr, "\n"); \
- }
- #else
- #define TRACE { }
- #endif
- /* Start/end addresses of functions and global variables on a device. */
- typedef std::vector<addr_pair> AddrVect;
- /* Addresses for one image and all devices. */
- typedef std::vector<AddrVect> DevAddrVect;
- /* Addresses for all images and all devices. */
- typedef std::map<const void *, DevAddrVect> ImgDevAddrMap;
- /* Image descriptor needed by __offload_[un]register_image. */
- struct TargetImageDesc {
- int64_t size;
- /* 10 characters is enough for max int value. */
- char name[sizeof ("lib0000000000.so")];
- char data[];
- };
- /* Image descriptors, indexed by a pointer obtained from libgomp. */
- typedef std::map<const void *, TargetImageDesc *> ImgDescMap;
- /* Total number of available devices. */
- static int num_devices;
- /* Total number of shared libraries with offloading to Intel MIC. */
- static int num_images;
- /* Two dimensional array: one key is a pointer to image,
- second key is number of device. Contains a vector of pointer pairs. */
- static ImgDevAddrMap *address_table;
- /* Descriptors of all images, registered in liboffloadmic. */
- static ImgDescMap *image_descriptors;
- /* Thread-safe registration of the main image. */
- static pthread_once_t main_image_is_registered = PTHREAD_ONCE_INIT;
- static VarDesc vd_host2tgt = {
- { 1, 1 }, /* dst, src */
- { 1, 0 }, /* in, out */
- 1, /* alloc_if */
- 1, /* free_if */
- 4, /* align */
- 0, /* mic_offset */
- { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
- is_stack_buf, sink_addr, alloc_disp,
- is_noncont_src, is_noncont_dst */
- 0, /* offset */
- 0, /* size */
- 1, /* count */
- 0, /* alloc */
- 0, /* into */
- 0 /* ptr */
- };
- static VarDesc vd_tgt2host = {
- { 1, 1 }, /* dst, src */
- { 0, 1 }, /* in, out */
- 1, /* alloc_if */
- 1, /* free_if */
- 4, /* align */
- 0, /* mic_offset */
- { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
- is_stack_buf, sink_addr, alloc_disp,
- is_noncont_src, is_noncont_dst */
- 0, /* offset */
- 0, /* size */
- 1, /* count */
- 0, /* alloc */
- 0, /* into */
- 0 /* ptr */
- };
- __attribute__((constructor))
- static void
- init (void)
- {
- const char *active_wait = getenv (OFFLOAD_ACTIVE_WAIT_ENV);
- /* Disable active wait by default to avoid useless CPU usage. */
- if (!active_wait)
- setenv (OFFLOAD_ACTIVE_WAIT_ENV, "0", 0);
- address_table = new ImgDevAddrMap;
- image_descriptors = new ImgDescMap;
- num_devices = _Offload_number_of_devices ();
- }
- extern "C" const char *
- GOMP_OFFLOAD_get_name (void)
- {
- const char *res = "intelmic";
- TRACE ("(): return %s", res);
- return res;
- }
- extern "C" unsigned int
- GOMP_OFFLOAD_get_caps (void)
- {
- unsigned int res = GOMP_OFFLOAD_CAP_OPENMP_400;
- TRACE ("(): return %x", res);
- return res;
- }
- extern "C" int
- GOMP_OFFLOAD_get_type (void)
- {
- enum offload_target_type res = OFFLOAD_TARGET_TYPE_INTEL_MIC;
- TRACE ("(): return %d", res);
- return res;
- }
- extern "C" int
- GOMP_OFFLOAD_get_num_devices (void)
- {
- TRACE ("(): return %d", num_devices);
- return num_devices;
- }
- static bool
- offload (const char *file, uint64_t line, int device, const char *name,
- int num_vars, VarDesc *vars, const void **async_data)
- {
- OFFLOAD ofld = __offload_target_acquire1 (&device, file, line);
- if (ofld)
- {
- if (async_data == NULL)
- return __offload_offload1 (ofld, name, 0, num_vars, vars, NULL, 0,
- NULL, NULL);
- else
- {
- OffloadFlags flags;
- flags.flags = 0;
- flags.bits.omp_async = 1;
- return __offload_offload3 (ofld, name, 0, num_vars, vars, NULL, 0,
- NULL, async_data, 0, NULL, flags, NULL);
- }
- }
- else
- {
- GOMP_PLUGIN_error ("%s:%d: Offload target acquire failed\n", file, line);
- return false;
- }
- }
- static void
- register_main_image ()
- {
- /* Do not check the return value, because old versions of liboffloadmic did
- not have return values. */
- __offload_register_image (&main_target_image);
- /* liboffloadmic will call GOMP_PLUGIN_target_task_completion when
- asynchronous task on target is completed. */
- __offload_register_task_callback (GOMP_PLUGIN_target_task_completion);
- }
- /* liboffloadmic loads and runs offload_target_main on all available devices
- during a first call to offload (). */
- extern "C" bool
- GOMP_OFFLOAD_init_device (int device)
- {
- TRACE ("(device = %d)", device);
- pthread_once (&main_image_is_registered, register_main_image);
- return offload (__FILE__, __LINE__, device, "__offload_target_init_proc", 0,
- NULL, NULL);
- }
- extern "C" bool
- GOMP_OFFLOAD_fini_device (int device)
- {
- TRACE ("(device = %d)", device);
- /* liboffloadmic will finalize target processes on all available devices. */
- __offload_unregister_image (&main_target_image);
- return true;
- }
- static bool
- get_target_table (int device, int &num_funcs, int &num_vars, void **&table)
- {
- VarDesc vd1[2] = { vd_tgt2host, vd_tgt2host };
- vd1[0].ptr = &num_funcs;
- vd1[0].size = sizeof (num_funcs);
- vd1[1].ptr = &num_vars;
- vd1[1].size = sizeof (num_vars);
- if (!offload (__FILE__, __LINE__, device, "__offload_target_table_p1", 2,
- vd1, NULL))
- return false;
- int table_size = num_funcs + 2 * num_vars;
- if (table_size > 0)
- {
- table = new void * [table_size];
- VarDesc vd2;
- vd2 = vd_tgt2host;
- vd2.ptr = table;
- vd2.size = table_size * sizeof (void *);
- return offload (__FILE__, __LINE__, device, "__offload_target_table_p2",
- 1, &vd2, NULL);
- }
- return true;
- }
- /* Offload TARGET_IMAGE to all available devices and fill address_table with
- corresponding target addresses. */
- static bool
- offload_image (const void *target_image)
- {
- void *image_start = ((void **) target_image)[0];
- void *image_end = ((void **) target_image)[1];
- TRACE ("(target_image = %p { %p, %p })",
- target_image, image_start, image_end);
- int64_t image_size = (uintptr_t) image_end - (uintptr_t) image_start;
- TargetImageDesc *image = (TargetImageDesc *) malloc (offsetof (TargetImageDesc, data)
- + image_size);
- if (!image)
- {
- GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__);
- return false;
- }
- image->size = image_size;
- sprintf (image->name, "lib%010d.so", num_images++);
- memcpy (image->data, image_start, image->size);
- TRACE ("() __offload_register_image %s { %p, %d }",
- image->name, image_start, image->size);
- /* Do not check the return value, because old versions of liboffloadmic did
- not have return values. */
- __offload_register_image (image);
- /* Receive tables for target_image from all devices. */
- DevAddrVect dev_table;
- bool ret = true;
- for (int dev = 0; dev < num_devices; dev++)
- {
- int num_funcs = 0;
- int num_vars = 0;
- void **table = NULL;
- ret &= get_target_table (dev, num_funcs, num_vars, table);
- AddrVect curr_dev_table;
- for (int i = 0; i < num_funcs; i++)
- {
- addr_pair tgt_addr;
- tgt_addr.start = (uintptr_t) table[i];
- tgt_addr.end = tgt_addr.start + 1;
- TRACE ("() func %d:\t0x%llx..0x%llx", i,
- tgt_addr.start, tgt_addr.end);
- curr_dev_table.push_back (tgt_addr);
- }
- for (int i = 0; i < num_vars; i++)
- {
- addr_pair tgt_addr;
- tgt_addr.start = (uintptr_t) table[num_funcs+i*2];
- tgt_addr.end = tgt_addr.start + (uintptr_t) table[num_funcs+i*2+1];
- TRACE ("() var %d:\t0x%llx..0x%llx", i, tgt_addr.start, tgt_addr.end);
- curr_dev_table.push_back (tgt_addr);
- }
- dev_table.push_back (curr_dev_table);
- delete [] table;
- }
- address_table->insert (std::make_pair (target_image, dev_table));
- image_descriptors->insert (std::make_pair (target_image, image));
- return ret;
- }
- /* Return the libgomp version number we're compatible with. There is
- no requirement for cross-version compatibility. */
- extern "C" unsigned
- GOMP_OFFLOAD_version (void)
- {
- return GOMP_VERSION;
- }
- extern "C" int
- GOMP_OFFLOAD_load_image (int device, const unsigned version,
- const void *target_image, addr_pair **result)
- {
- TRACE ("(device = %d, target_image = %p)", device, target_image);
- if (GOMP_VERSION_DEV (version) > GOMP_VERSION_INTEL_MIC)
- {
- GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin"
- " (expected %u, received %u)",
- GOMP_VERSION_INTEL_MIC, GOMP_VERSION_DEV (version));
- return -1;
- }
- /* If target_image is already present in address_table, then there is no need
- to offload it. */
- if (address_table->count (target_image) == 0)
- {
- /* If fail, return -1 as error code. */
- if (!offload_image (target_image))
- return -1;
- }
- AddrVect *curr_dev_table = &(*address_table)[target_image][device];
- int table_size = curr_dev_table->size ();
- addr_pair *table = (addr_pair *) malloc (table_size * sizeof (addr_pair));
- if (table == NULL)
- {
- GOMP_PLUGIN_error ("%s: Can't allocate memory\n", __FILE__);
- return -1;
- }
- std::copy (curr_dev_table->begin (), curr_dev_table->end (), table);
- *result = table;
- return table_size;
- }
- extern "C" bool
- GOMP_OFFLOAD_unload_image (int device, unsigned version,
- const void *target_image)
- {
- if (GOMP_VERSION_DEV (version) > GOMP_VERSION_INTEL_MIC)
- {
- GOMP_PLUGIN_error ("Offload data incompatible with intelmic plugin"
- " (expected %u, received %u)",
- GOMP_VERSION_INTEL_MIC, GOMP_VERSION_DEV (version));
- return false;
- }
- TRACE ("(device = %d, target_image = %p)", device, target_image);
- /* liboffloadmic unloads the image from all available devices. */
- if (image_descriptors->count (target_image) > 0)
- {
- TargetImageDesc *image_desc = (*image_descriptors)[target_image];
- __offload_unregister_image (image_desc);
- free (image_desc);
- address_table->erase (target_image);
- image_descriptors->erase (target_image);
- }
- return true;
- }
- extern "C" void *
- GOMP_OFFLOAD_alloc (int device, size_t size)
- {
- TRACE ("(device = %d, size = %d)", device, size);
- void *tgt_ptr;
- VarDesc vd[2] = { vd_host2tgt, vd_tgt2host };
- vd[0].ptr = &size;
- vd[0].size = sizeof (size);
- vd[1].ptr = &tgt_ptr;
- vd[1].size = sizeof (void *);
- if (!offload (__FILE__, __LINE__, device, "__offload_target_alloc", 2,
- vd, NULL))
- return NULL;
- return tgt_ptr;
- }
- extern "C" bool
- GOMP_OFFLOAD_free (int device, void *tgt_ptr)
- {
- TRACE ("(device = %d, tgt_ptr = %p)", device, tgt_ptr);
- VarDesc vd = vd_host2tgt;
- vd.ptr = &tgt_ptr;
- vd.size = sizeof (void *);
- return offload (__FILE__, __LINE__, device, "__offload_target_free", 1,
- &vd, NULL);
- }
- extern "C" bool
- GOMP_OFFLOAD_host2dev (int device, void *tgt_ptr, const void *host_ptr,
- size_t size)
- {
- TRACE ("(device = %d, tgt_ptr = %p, host_ptr = %p, size = %d)",
- device, tgt_ptr, host_ptr, size);
- if (!size)
- return true;
- VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
- vd1[0].ptr = &tgt_ptr;
- vd1[0].size = sizeof (void *);
- vd1[1].ptr = &size;
- vd1[1].size = sizeof (size);
- if (!offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p1", 2,
- vd1, NULL))
- return false;
- VarDesc vd2 = vd_host2tgt;
- vd2.ptr = (void *) host_ptr;
- vd2.size = size;
- return offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p2", 1,
- &vd2, NULL);
- }
- extern "C" bool
- GOMP_OFFLOAD_dev2host (int device, void *host_ptr, const void *tgt_ptr,
- size_t size)
- {
- TRACE ("(device = %d, host_ptr = %p, tgt_ptr = %p, size = %d)",
- device, host_ptr, tgt_ptr, size);
- if (!size)
- return true;
- VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
- vd1[0].ptr = &tgt_ptr;
- vd1[0].size = sizeof (void *);
- vd1[1].ptr = &size;
- vd1[1].size = sizeof (size);
- if (!offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p1", 2,
- vd1, NULL))
- return false;
- VarDesc vd2 = vd_tgt2host;
- vd2.ptr = (void *) host_ptr;
- vd2.size = size;
- return offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p2", 1,
- &vd2, NULL);
- }
- extern "C" bool
- GOMP_OFFLOAD_dev2dev (int device, void *dst_ptr, const void *src_ptr,
- size_t size)
- {
- TRACE ("(device = %d, dst_ptr = %p, src_ptr = %p, size = %d)",
- device, dst_ptr, src_ptr, size);
- if (!size)
- return true;
- VarDesc vd[3] = { vd_host2tgt, vd_host2tgt, vd_host2tgt };
- vd[0].ptr = &dst_ptr;
- vd[0].size = sizeof (void *);
- vd[1].ptr = &src_ptr;
- vd[1].size = sizeof (void *);
- vd[2].ptr = &size;
- vd[2].size = sizeof (size);
- return offload (__FILE__, __LINE__, device, "__offload_target_tgt2tgt", 3,
- vd, NULL);
- }
- extern "C" void
- GOMP_OFFLOAD_async_run (int device, void *tgt_fn, void *tgt_vars,
- void **, void *async_data)
- {
- TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p, async_data = %p)", device,
- tgt_fn, tgt_vars, async_data);
- VarDesc vd[2] = { vd_host2tgt, vd_host2tgt };
- vd[0].ptr = &tgt_fn;
- vd[0].size = sizeof (void *);
- vd[1].ptr = &tgt_vars;
- vd[1].size = sizeof (void *);
- offload (__FILE__, __LINE__, device, "__offload_target_run", 2, vd,
- (const void **) async_data);
- }
- extern "C" void
- GOMP_OFFLOAD_run (int device, void *tgt_fn, void *tgt_vars, void **)
- {
- TRACE ("(device = %d, tgt_fn = %p, tgt_vars = %p)", device, tgt_fn, tgt_vars);
- GOMP_OFFLOAD_async_run (device, tgt_fn, tgt_vars, NULL, NULL);
- }
|