liboffloadmic/plugin/libgomp-plugin-intelmic.cpp

   1 /* Plugin for offload execution on Intel MIC devices.
   2
   3    Copyright (C) 2014 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
  42 #define LD_LIBRARY_PATH_ENV     "LD_LIBRARY_PATH"
  43 #define MIC_LD_LIBRARY_PATH_ENV "MIC_LD_LIBRARY_PATH"
  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<void *, DevAddrVect> ImgDevAddrMap;
  65
  66
  67 /* Total number of available devices.  */
  68 static int num_devices;
  69
  70 /* Total number of shared libraries with offloading to Intel MIC.  */
  71 static int num_images;
  72
  73 /* Two dimensional array: one key is a pointer to image,
  74    second key is number of device.  Contains a vector of pointer pairs.  */
  75 static ImgDevAddrMap *address_table;
  76
  77 /* Thread-safe registration of the main image.  */
  78 static pthread_once_t main_image_is_registered = PTHREAD_ONCE_INIT;
  79
  80 static VarDesc vd_host2tgt = {
  81   { 1, 1 },                   /* dst, src                             */
  82   { 1, 0 },                   /* in, out                              */
  83   1,                          /* alloc_if                             */
  84   1,                          /* free_if                              */
  85   4,                          /* align                                */
  86   0,                          /* mic_offset                           */
  87   { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
  88                                  is_stack_buf, sink_addr, alloc_disp,
  89                                  is_noncont_src, is_noncont_dst       */
  90   0,                          /* offset                               */
  91   0,                          /* size                                 */
  92   1,                          /* count                                */
  93   0,                          /* alloc                                */
  94   0,                          /* into                                 */
  95   0                           /* ptr                                  */
  96 };
  97
  98 static VarDesc vd_tgt2host = {
  99   { 1, 1 },                   /* dst, src                             */
 100   { 0, 1 },                   /* in, out                              */
 101   1,                          /* alloc_if                             */
 102   1,                          /* free_if                              */
 103   4,                          /* align                                */
 104   0,                          /* mic_offset                           */
 105   { 0, 0, 0, 0, 0, 0, 0, 0 }, /* is_static, is_static_dstn, has_length,
 106                                  is_stack_buf, sink_addr, alloc_disp,
 107                                  is_noncont_src, is_noncont_dst       */
 108   0,                          /* offset                               */
 109   0,                          /* size                                 */
 110   1,                          /* count                                */
 111   0,                          /* alloc                                */
 112   0,                          /* into                                 */
 113   0                           /* ptr                                  */
 114 };
 115
 116
 117 /* Add path specified in LD_LIBRARY_PATH to MIC_LD_LIBRARY_PATH, which is
 118    required by liboffloadmic.  */
 119 __attribute__((constructor))
 120 static void
 121 init (void)
 122 {
 123   const char *ld_lib_path = getenv (LD_LIBRARY_PATH_ENV);
 124   const char *mic_lib_path = getenv (MIC_LD_LIBRARY_PATH_ENV);
 125
 126   if (!ld_lib_path)
 127     goto out;
 128
 129   if (!mic_lib_path)
 130     setenv (MIC_LD_LIBRARY_PATH_ENV, ld_lib_path, 1);
 131   else
 132     {
 133       size_t len = strlen (mic_lib_path) + strlen (ld_lib_path) + 2;
 134       bool use_alloca = len <= 2048;
 135       char *mic_lib_path_new = (char *) (use_alloca ? alloca (len)
 136                                                     : malloc (len));
 137       if (!mic_lib_path_new)
 138         {
 139           fprintf (stderr, "%s: Can't allocate memory\n", __FILE__);
 140           exit (1);
 141         }
 142
 143       sprintf (mic_lib_path_new, "%s:%s", mic_lib_path, ld_lib_path);
 144       setenv (MIC_LD_LIBRARY_PATH_ENV, mic_lib_path_new, 1);
 145
 146       if (!use_alloca)
 147         free (mic_lib_path_new);
 148     }
 149
 150 out:
 151   address_table = new ImgDevAddrMap;
 152   num_devices = _Offload_number_of_devices ();
 153 }
 154
 155 extern "C" const char *
 156 GOMP_OFFLOAD_get_name (void)
 157 {
 158   const char *res = "intelmic";
 159   TRACE ("(): return %s", res);
 160   return res;
 161 }
 162
 163 extern "C" unsigned int
 164 GOMP_OFFLOAD_get_caps (void)
 165 {
 166   unsigned int res = GOMP_OFFLOAD_CAP_OPENMP_400;
 167   TRACE ("(): return %x", res);
 168   return res;
 169 }
 170
 171 extern "C" enum offload_target_type
 172 GOMP_OFFLOAD_get_type (void)
 173 {
 174   enum offload_target_type res = OFFLOAD_TARGET_TYPE_INTEL_MIC;
 175   TRACE ("(): return %d", res);
 176   return res;
 177 }
 178
 179 extern "C" int
 180 GOMP_OFFLOAD_get_num_devices (void)
 181 {
 182   TRACE ("(): return %d", num_devices);
 183   return num_devices;
 184 }
 185
 186 static void
 187 offload (const char *file, uint64_t line, int device, const char *name,
 188          int num_vars, VarDesc *vars, VarDesc2 *vars2)
 189 {
 190   OFFLOAD ofld = __offload_target_acquire1 (&device, file, line);
 191   if (ofld)
 192     __offload_offload1 (ofld, name, 0, num_vars, vars, vars2, 0, NULL, NULL);
 193   else
 194     {
 195       fprintf (stderr, "%s:%d: Offload target acquire failed\n", file, line);
 196       exit (1);
 197     }
 198 }
 199
 200 static void
 201 register_main_image ()
 202 {
 203   __offload_register_image (&main_target_image);
 204 }
 205
 206 /* liboffloadmic loads and runs offload_target_main on all available devices
 207    during a first call to offload ().  */
 208 extern "C" void
 209 GOMP_OFFLOAD_init_device (int device)
 210 {
 211   TRACE ("");
 212   pthread_once (&main_image_is_registered, register_main_image);
 213   offload (__FILE__, __LINE__, device, "__offload_target_init_proc", 0,
 214            NULL, NULL);
 215 }
 216
 217 extern "C" void
 218 GOMP_OFFLOAD_fini_device (int device)
 219 {
 220   TRACE ("");
 221   /* Unreachable for GOMP_OFFLOAD_CAP_OPENMP_400.  */
 222   abort ();
 223 }
 224
 225 static void
 226 get_target_table (int device, int &num_funcs, int &num_vars, void **&table)
 227 {
 228   VarDesc vd1[2] = { vd_tgt2host, vd_tgt2host };
 229   vd1[0].ptr = &num_funcs;
 230   vd1[0].size = sizeof (num_funcs);
 231   vd1[1].ptr = &num_vars;
 232   vd1[1].size = sizeof (num_vars);
 233   VarDesc2 vd1g[2] = { { "num_funcs", 0 }, { "num_vars", 0 } };
 234
 235   offload (__FILE__, __LINE__, device, "__offload_target_table_p1", 2,
 236            vd1, vd1g);
 237
 238   int table_size = num_funcs + 2 * num_vars;
 239   if (table_size > 0)
 240     {
 241       table = new void * [table_size];
 242
 243       VarDesc vd2;
 244       vd2 = vd_tgt2host;
 245       vd2.ptr = table;
 246       vd2.size = table_size * sizeof (void *);
 247       VarDesc2 vd2g = { "table", 0 };
 248
 249       offload (__FILE__, __LINE__, device, "__offload_target_table_p2", 1,
 250                &vd2, &vd2g);
 251     }
 252 }
 253
 254 /* Offload TARGET_IMAGE to all available devices and fill address_table with
 255    corresponding target addresses.  */
 256
 257 static void
 258 offload_image (void *target_image)
 259 {
 260   struct TargetImage {
 261     int64_t size;
 262     /* 10 characters is enough for max int value.  */
 263     char name[sizeof ("lib0000000000.so")];
 264     char data[];
 265   } __attribute__ ((packed));
 266
 267   void *image_start = ((void **) target_image)[0];
 268   void *image_end   = ((void **) target_image)[1];
 269
 270   TRACE ("(target_image = %p { %p, %p })",
 271          target_image, image_start, image_end);
 272
 273   int64_t image_size = (uintptr_t) image_end - (uintptr_t) image_start;
 274   TargetImage *image
 275     = (TargetImage *) malloc (sizeof (int64_t) + sizeof ("lib0000000000.so")
 276                               + image_size);
 277   if (!image)
 278     {
 279       fprintf (stderr, "%s: Can't allocate memory\n", __FILE__);
 280       exit (1);
 281     }
 282
 283   image->size = image_size;
 284   sprintf (image->name, "lib%010d.so", num_images++);
 285   memcpy (image->data, image_start, image->size);
 286
 287   TRACE ("() __offload_register_image %s { %p, %d }",
 288          image->name, image_start, image->size);
 289   __offload_register_image (image);
 290
 291   /* Receive tables for target_image from all devices.  */
 292   DevAddrVect dev_table;
 293   for (int dev = 0; dev < num_devices; dev++)
 294     {
 295       int num_funcs = 0;
 296       int num_vars = 0;
 297       void **table = NULL;
 298
 299       get_target_table (dev, num_funcs, num_vars, table);
 300
 301       AddrVect curr_dev_table;
 302
 303       for (int i = 0; i < num_funcs; i++)
 304         {
 305           addr_pair tgt_addr;
 306           tgt_addr.start = (uintptr_t) table[i];
 307           tgt_addr.end = tgt_addr.start + 1;
 308           TRACE ("() func %d:\t0x%llx..0x%llx", i,
 309                  tgt_addr.start, tgt_addr.end);
 310           curr_dev_table.push_back (tgt_addr);
 311         }
 312
 313       for (int i = 0; i < num_vars; i++)
 314         {
 315           addr_pair tgt_addr;
 316           tgt_addr.start = (uintptr_t) table[num_funcs+i*2];
 317           tgt_addr.end = tgt_addr.start + (uintptr_t) table[num_funcs+i*2+1];
 318           TRACE ("() var %d:\t0x%llx..0x%llx", i, tgt_addr.start, tgt_addr.end);
 319           curr_dev_table.push_back (tgt_addr);
 320         }
 321
 322       dev_table.push_back (curr_dev_table);
 323     }
 324
 325   address_table->insert (std::make_pair (target_image, dev_table));
 326
 327   free (image);
 328 }
 329
 330 extern "C" int
 331 GOMP_OFFLOAD_load_image (int device, void *target_image, addr_pair **result)
 332 {
 333   TRACE ("(device = %d, target_image = %p)", device, target_image);
 334
 335   /* If target_image is already present in address_table, then there is no need
 336      to offload it.  */
 337   if (address_table->count (target_image) == 0)
 338     offload_image (target_image);
 339
 340   AddrVect *curr_dev_table = &(*address_table)[target_image][device];
 341   int table_size = curr_dev_table->size ();
 342   addr_pair *table = (addr_pair *) malloc (table_size * sizeof (addr_pair));
 343   if (table == NULL)
 344     {
 345       fprintf (stderr, "%s: Can't allocate memory\n", __FILE__);
 346       exit (1);
 347     }
 348
 349   std::copy (curr_dev_table->begin (), curr_dev_table->end (), table);
 350   *result = table;
 351   return table_size;
 352 }
 353
 354 extern "C" void
 355 GOMP_OFFLOAD_unload_image (int device, void *target_image)
 356 {
 357   TRACE ("(device = %d, target_image = %p)", device, target_image);
 358
 359   /* TODO: Currently liboffloadmic doesn't support __offload_unregister_image
 360      for libraries.  */
 361
 362   address_table->erase (target_image);
 363 }
 364
 365 extern "C" void *
 366 GOMP_OFFLOAD_alloc (int device, size_t size)
 367 {
 368   TRACE ("(size = %d)", size);
 369
 370   void *tgt_ptr;
 371   VarDesc vd1[2] = { vd_host2tgt, vd_tgt2host };
 372   vd1[0].ptr = &size;
 373   vd1[0].size = sizeof (size);
 374   vd1[1].ptr = &tgt_ptr;
 375   vd1[1].size = sizeof (void *);
 376   VarDesc2 vd1g[2] = { { "size", 0 }, { "tgt_ptr", 0 } };
 377
 378   offload (__FILE__, __LINE__, device, "__offload_target_alloc", 2, vd1, vd1g);
 379
 380   return tgt_ptr;
 381 }
 382
 383 extern "C" void
 384 GOMP_OFFLOAD_free (int device, void *tgt_ptr)
 385 {
 386   TRACE ("(tgt_ptr = %p)", tgt_ptr);
 387
 388   VarDesc vd1 = vd_host2tgt;
 389   vd1.ptr = &tgt_ptr;
 390   vd1.size = sizeof (void *);
 391   VarDesc2 vd1g = { "tgt_ptr", 0 };
 392
 393   offload (__FILE__, __LINE__, device, "__offload_target_free", 1, &vd1, &vd1g);
 394 }
 395
 396 extern "C" void *
 397 GOMP_OFFLOAD_host2dev (int device, void *tgt_ptr, const void *host_ptr,
 398                        size_t size)
 399 {
 400   TRACE ("(tgt_ptr = %p, host_ptr = %p, size = %d)", tgt_ptr, host_ptr, size);
 401   if (!size)
 402     return tgt_ptr;
 403
 404   VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
 405   vd1[0].ptr = &tgt_ptr;
 406   vd1[0].size = sizeof (void *);
 407   vd1[1].ptr = &size;
 408   vd1[1].size = sizeof (size);
 409   VarDesc2 vd1g[2] = { { "tgt_ptr", 0 }, { "size", 0 } };
 410
 411   offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p1", 2,
 412            vd1, vd1g);
 413
 414   VarDesc vd2 = vd_host2tgt;
 415   vd2.ptr = (void *) host_ptr;
 416   vd2.size = size;
 417   VarDesc2 vd2g = { "var", 0 };
 418
 419   offload (__FILE__, __LINE__, device, "__offload_target_host2tgt_p2", 1,
 420            &vd2, &vd2g);
 421
 422   return tgt_ptr;
 423 }
 424
 425 extern "C" void *
 426 GOMP_OFFLOAD_dev2host (int device, void *host_ptr, const void *tgt_ptr,
 427                        size_t size)
 428 {
 429   TRACE ("(host_ptr = %p, tgt_ptr = %p, size = %d)", host_ptr, tgt_ptr, size);
 430   if (!size)
 431     return host_ptr;
 432
 433   VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
 434   vd1[0].ptr = &tgt_ptr;
 435   vd1[0].size = sizeof (void *);
 436   vd1[1].ptr = &size;
 437   vd1[1].size = sizeof (size);
 438   VarDesc2 vd1g[2] = { { "tgt_ptr", 0 }, { "size", 0 } };
 439
 440   offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p1", 2,
 441            vd1, vd1g);
 442
 443   VarDesc vd2 = vd_tgt2host;
 444   vd2.ptr = (void *) host_ptr;
 445   vd2.size = size;
 446   VarDesc2 vd2g = { "var", 0 };
 447
 448   offload (__FILE__, __LINE__, device, "__offload_target_tgt2host_p2", 1,
 449            &vd2, &vd2g);
 450
 451   return host_ptr;
 452 }
 453
 454 extern "C" void
 455 GOMP_OFFLOAD_run (int device, void *tgt_fn, void *tgt_vars)
 456 {
 457   TRACE ("(tgt_fn = %p, tgt_vars = %p)", tgt_fn, tgt_vars);
 458
 459   VarDesc vd1[2] = { vd_host2tgt, vd_host2tgt };
 460   vd1[0].ptr = &tgt_fn;
 461   vd1[0].size = sizeof (void *);
 462   vd1[1].ptr = &tgt_vars;
 463   vd1[1].size = sizeof (void *);
 464   VarDesc2 vd1g[2] = { { "tgt_fn", 0 }, { "tgt_vars", 0 } };
 465
 466   offload (__FILE__, __LINE__, device, "__offload_target_run", 2, vd1, vd1g);
 467 }