openmp/libomptarget/src/interface.cpp

   1 //===-------- interface.cpp - Target independent OpenMP target RTL --------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Implementation of the interface to be used by Clang during the codegen of a
  10 // target region.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "device.h"
  15 #include "private.h"
  16 #include "rtl.h"
  17
  18 #include <cassert>
  19 #include <cstdio>
  20 #include <cstdlib>
  21 #include <mutex>
  22
  23 ////////////////////////////////////////////////////////////////////////////////
  24 /// manage the success or failure of a target construct
  25 static void HandleDefaultTargetOffload() {
  26   PM->TargetOffloadMtx.lock();
  27   if (PM->TargetOffloadPolicy == tgt_default) {
  28     if (omp_get_num_devices() > 0) {
  29       DP("Default TARGET OFFLOAD policy is now mandatory "
  30          "(devices were found)\n");
  31       PM->TargetOffloadPolicy = tgt_mandatory;
  32     } else {
  33       DP("Default TARGET OFFLOAD policy is now disabled "
  34          "(no devices were found)\n");
  35       PM->TargetOffloadPolicy = tgt_disabled;
  36     }
  37   }
  38   PM->TargetOffloadMtx.unlock();
  39 }
  40
  41 static int IsOffloadDisabled() {
  42   if (PM->TargetOffloadPolicy == tgt_default)
  43     HandleDefaultTargetOffload();
  44   return PM->TargetOffloadPolicy == tgt_disabled;
  45 }
  46
  47 static void HandleTargetOutcome(bool success, ident_t *loc = nullptr) {
  48   switch (PM->TargetOffloadPolicy) {
  49   case tgt_disabled:
  50     if (success) {
  51       FATAL_MESSAGE0(1, "expected no offloading while offloading is disabled");
  52     }
  53     break;
  54   case tgt_default:
  55     FATAL_MESSAGE0(1, "default offloading policy must be switched to "
  56                       "mandatory or disabled");
  57     break;
  58   case tgt_mandatory:
  59     if (!success) {
  60       if (getInfoLevel() & OMP_INFOTYPE_DUMP_TABLE)
  61         for (const auto &Device : PM->Devices)
  62           dumpTargetPointerMappings(loc, Device);
  63       else
  64         FAILURE_MESSAGE("Run with LIBOMPTARGET_DEBUG=%d to dump host-target "
  65                         "pointer mappings.\n",
  66                         OMP_INFOTYPE_DUMP_TABLE);
  67
  68       SourceInfo info(loc);
  69       if (info.isAvailible())
  70         fprintf(stderr, "%s:%d:%d: ", info.getFilename(), info.getLine(),
  71                 info.getColumn());
  72       else
  73         FAILURE_MESSAGE("Source location information not present. Compile with "
  74                         "-g or -gline-tables-only.\n");
  75       FATAL_MESSAGE0(
  76           1, "failure of target construct while offloading is mandatory");
  77     } else {
  78       if (getInfoLevel() & OMP_INFOTYPE_DUMP_TABLE)
  79         for (const auto &Device : PM->Devices)
  80           dumpTargetPointerMappings(loc, Device);
  81     }
  82     break;
  83   }
  84 }
  85
  86 ////////////////////////////////////////////////////////////////////////////////
  87 /// adds requires flags
  88 EXTERN void __tgt_register_requires(int64_t flags) {
  89   TIMESCOPE();
  90   PM->RTLs.RegisterRequires(flags);
  91 }
  92
  93 ////////////////////////////////////////////////////////////////////////////////
  94 /// adds a target shared library to the target execution image
  95 EXTERN void __tgt_register_lib(__tgt_bin_desc *desc) {
  96   TIMESCOPE();
  97   PM->RTLs.RegisterLib(desc);
  98 }
  99
 100 ////////////////////////////////////////////////////////////////////////////////
 101 /// unloads a target shared library
 102 EXTERN void __tgt_unregister_lib(__tgt_bin_desc *desc) {
 103   TIMESCOPE();
 104   PM->RTLs.UnregisterLib(desc);
 105 }
 106
 107 /// creates host-to-target data mapping, stores it in the
 108 /// libomptarget.so internal structure (an entry in a stack of data maps)
 109 /// and passes the data to the device.
 110 EXTERN void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
 111     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
 112   TIMESCOPE();
 113   __tgt_target_data_begin_mapper(nullptr, device_id, arg_num, args_base, args,
 114                                  arg_sizes, arg_types, nullptr, nullptr);
 115 }
 116
 117 EXTERN void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
 118     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
 119     int32_t depNum, void *depList, int32_t noAliasDepNum,
 120     void *noAliasDepList) {
 121   TIMESCOPE();
 122   if (depNum + noAliasDepNum > 0)
 123     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 124
 125   __tgt_target_data_begin_mapper(nullptr, device_id, arg_num, args_base, args,
 126                                  arg_sizes, arg_types, nullptr, nullptr);
 127 }
 128
 129 EXTERN void __tgt_target_data_begin_mapper(ident_t *loc, int64_t device_id,
 130                                            int32_t arg_num, void **args_base,
 131                                            void **args, int64_t *arg_sizes,
 132                                            int64_t *arg_types,
 133                                            map_var_info_t *arg_names,
 134                                            void **arg_mappers) {
 135   TIMESCOPE();
 136   if (IsOffloadDisabled()) return;
 137
 138   DP("Entering data begin region for device %" PRId64 " with %d mappings\n",
 139       device_id, arg_num);
 140
 141   // No devices available?
 142   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
 143     device_id = omp_get_default_device();
 144     DP("Use default device id %" PRId64 "\n", device_id);
 145   }
 146
 147   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
 148     DP("Failed to get device %" PRId64 " ready\n", device_id);
 149     HandleTargetOutcome(false, loc);
 150     return;
 151   }
 152
 153   DeviceTy &Device = PM->Devices[device_id];
 154
 155   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
 156     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
 157                          arg_names, "Entering OpenMP data region");
 158 #ifdef OMPTARGET_DEBUG
 159   for (int i = 0; i < arg_num; ++i) {
 160     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
 161        ", Type=0x%" PRIx64 ", Name=%s\n",
 162        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
 163        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
 164   }
 165 #endif
 166
 167   int rc = targetDataBegin(Device, arg_num, args_base, args, arg_sizes,
 168                            arg_types, arg_names, arg_mappers, nullptr);
 169   HandleTargetOutcome(rc == OFFLOAD_SUCCESS, loc);
 170 }
 171
 172 EXTERN void __tgt_target_data_begin_nowait_mapper(
 173     ident_t *loc, int64_t device_id, int32_t arg_num, void **args_base,
 174     void **args, int64_t *arg_sizes, int64_t *arg_types,
 175     map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
 176     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
 177   TIMESCOPE();
 178   if (depNum + noAliasDepNum > 0)
 179     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 180
 181   __tgt_target_data_begin_mapper(loc, device_id, arg_num, args_base, args,
 182                                  arg_sizes, arg_types, arg_names, arg_mappers);
 183 }
 184
 185 /// passes data from the target, releases target memory and destroys
 186 /// the host-target mapping (top entry from the stack of data maps)
 187 /// created by the last __tgt_target_data_begin.
 188 EXTERN void __tgt_target_data_end(int64_t device_id, int32_t arg_num,
 189     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
 190   TIMESCOPE();
 191   __tgt_target_data_end_mapper(nullptr, device_id, arg_num, args_base, args,
 192                                arg_sizes, arg_types, nullptr, nullptr);
 193 }
 194
 195 EXTERN void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
 196     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
 197     int32_t depNum, void *depList, int32_t noAliasDepNum,
 198     void *noAliasDepList) {
 199   TIMESCOPE();
 200   if (depNum + noAliasDepNum > 0)
 201     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 202
 203   __tgt_target_data_end_mapper(nullptr, device_id, arg_num, args_base, args,
 204                                arg_sizes, arg_types, nullptr, nullptr);
 205 }
 206
 207 EXTERN void __tgt_target_data_end_mapper(ident_t *loc, int64_t device_id,
 208                                          int32_t arg_num, void **args_base,
 209                                          void **args, int64_t *arg_sizes,
 210                                          int64_t *arg_types,
 211                                          map_var_info_t *arg_names,
 212                                          void **arg_mappers) {
 213   TIMESCOPE();
 214   if (IsOffloadDisabled()) return;
 215   DP("Entering data end region with %d mappings\n", arg_num);
 216
 217   // No devices available?
 218   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
 219     device_id = omp_get_default_device();
 220   }
 221
 222   PM->RTLsMtx.lock();
 223   size_t DevicesSize = PM->Devices.size();
 224   PM->RTLsMtx.unlock();
 225   if (DevicesSize <= (size_t)device_id) {
 226     DP("Device ID  %" PRId64 " does not have a matching RTL.\n", device_id);
 227     HandleTargetOutcome(false, loc);
 228     return;
 229   }
 230
 231   DeviceTy &Device = PM->Devices[device_id];
 232   if (!Device.IsInit) {
 233     DP("Uninit device: ignore");
 234     HandleTargetOutcome(false, loc);
 235     return;
 236   }
 237
 238   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
 239     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
 240                          arg_names, "Exiting OpenMP data region");
 241 #ifdef OMPTARGET_DEBUG
 242   for (int i=0; i<arg_num; ++i) {
 243     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
 244        ", Type=0x%" PRIx64 ", Name=%s\n",
 245        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
 246        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
 247   }
 248 #endif
 249
 250   int rc = targetDataEnd(Device, arg_num, args_base, args, arg_sizes, arg_types,
 251                          arg_names, arg_mappers, nullptr);
 252   HandleTargetOutcome(rc == OFFLOAD_SUCCESS, loc);
 253 }
 254
 255 EXTERN void __tgt_target_data_end_nowait_mapper(
 256     ident_t *loc, int64_t device_id, int32_t arg_num, void **args_base,
 257     void **args, int64_t *arg_sizes, int64_t *arg_types,
 258     map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
 259     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
 260   TIMESCOPE();
 261   if (depNum + noAliasDepNum > 0)
 262     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 263
 264   __tgt_target_data_end_mapper(loc, device_id, arg_num, args_base, args,
 265                                arg_sizes, arg_types, arg_names, arg_mappers);
 266 }
 267
 268 EXTERN void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
 269     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
 270   TIMESCOPE();
 271   __tgt_target_data_update_mapper(nullptr, device_id, arg_num, args_base, args,
 272                                   arg_sizes, arg_types, nullptr, nullptr);
 273 }
 274
 275 EXTERN void __tgt_target_data_update_nowait(int64_t device_id, int32_t arg_num,
 276     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
 277     int32_t depNum, void *depList, int32_t noAliasDepNum,
 278     void *noAliasDepList) {
 279   TIMESCOPE();
 280   if (depNum + noAliasDepNum > 0)
 281     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 282
 283   __tgt_target_data_update_mapper(nullptr, device_id, arg_num, args_base, args,
 284                                   arg_sizes, arg_types, nullptr, nullptr);
 285 }
 286
 287 EXTERN void __tgt_target_data_update_mapper(ident_t *loc, int64_t device_id,
 288                                             int32_t arg_num, void **args_base,
 289                                             void **args, int64_t *arg_sizes,
 290                                             int64_t *arg_types,
 291                                             map_var_info_t *arg_names,
 292                                             void **arg_mappers) {
 293   TIMESCOPE();
 294   if (IsOffloadDisabled()) return;
 295   DP("Entering data update with %d mappings\n", arg_num);
 296
 297   // No devices available?
 298   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
 299     device_id = omp_get_default_device();
 300   }
 301
 302   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
 303     DP("Failed to get device %" PRId64 " ready\n", device_id);
 304     HandleTargetOutcome(false, loc);
 305     return;
 306   }
 307
 308   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
 309     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
 310                          arg_names, "Updating OpenMP data");
 311
 312   DeviceTy &Device = PM->Devices[device_id];
 313   int rc = targetDataUpdate(Device, arg_num, args_base, args, arg_sizes,
 314                             arg_types, arg_names, arg_mappers);
 315   HandleTargetOutcome(rc == OFFLOAD_SUCCESS, loc);
 316 }
 317
 318 EXTERN void __tgt_target_data_update_nowait_mapper(
 319     ident_t *loc, int64_t device_id, int32_t arg_num, void **args_base,
 320     void **args, int64_t *arg_sizes, int64_t *arg_types,
 321     map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
 322     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
 323   TIMESCOPE();
 324   if (depNum + noAliasDepNum > 0)
 325     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 326
 327   __tgt_target_data_update_mapper(loc, device_id, arg_num, args_base, args,
 328                                   arg_sizes, arg_types, arg_names, arg_mappers);
 329 }
 330
 331 EXTERN int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
 332     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
 333   TIMESCOPE();
 334   return __tgt_target_mapper(nullptr, device_id, host_ptr, arg_num, args_base,
 335                              args, arg_sizes, arg_types, nullptr, nullptr);
 336 }
 337
 338 EXTERN int __tgt_target_nowait(int64_t device_id, void *host_ptr,
 339     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
 340     int64_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
 341     void *noAliasDepList) {
 342   TIMESCOPE();
 343   if (depNum + noAliasDepNum > 0)
 344     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 345
 346   return __tgt_target_mapper(nullptr, device_id, host_ptr, arg_num, args_base,
 347                              args, arg_sizes, arg_types, nullptr, nullptr);
 348 }
 349
 350 EXTERN int __tgt_target_mapper(ident_t *loc, int64_t device_id, void *host_ptr,
 351                                int32_t arg_num, void **args_base, void **args,
 352                                int64_t *arg_sizes, int64_t *arg_types,
 353                                map_var_info_t *arg_names, void **arg_mappers) {
 354   TIMESCOPE();
 355   if (IsOffloadDisabled()) return OFFLOAD_FAIL;
 356   DP("Entering target region with entry point " DPxMOD " and device Id %"
 357       PRId64 "\n", DPxPTR(host_ptr), device_id);
 358
 359   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
 360     device_id = omp_get_default_device();
 361   }
 362
 363   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
 364     REPORT("Failed to get device %" PRId64 " ready\n", device_id);
 365     HandleTargetOutcome(false, loc);
 366     return OFFLOAD_FAIL;
 367   }
 368
 369   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
 370     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
 371                          arg_names, "Entering OpenMP kernel");
 372 #ifdef OMPTARGET_DEBUG
 373   for (int i=0; i<arg_num; ++i) {
 374     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
 375        ", Type=0x%" PRIx64 ", Name=%s\n",
 376        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
 377        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
 378   }
 379 #endif
 380
 381   int rc = target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
 382                   arg_types, arg_names, arg_mappers, 0, 0, false /*team*/);
 383   HandleTargetOutcome(rc == OFFLOAD_SUCCESS, loc);
 384   return rc;
 385 }
 386
 387 EXTERN int __tgt_target_nowait_mapper(
 388     ident_t *loc, int64_t device_id, void *host_ptr, int32_t arg_num,
 389     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
 390     map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
 391     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
 392   TIMESCOPE();
 393   if (depNum + noAliasDepNum > 0)
 394     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 395
 396   return __tgt_target_mapper(loc, device_id, host_ptr, arg_num, args_base, args,
 397                              arg_sizes, arg_types, arg_names, arg_mappers);
 398 }
 399
 400 EXTERN int __tgt_target_teams(int64_t device_id, void *host_ptr,
 401     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
 402     int64_t *arg_types, int32_t team_num, int32_t thread_limit) {
 403   TIMESCOPE();
 404   return __tgt_target_teams_mapper(nullptr, device_id, host_ptr, arg_num,
 405                                    args_base, args, arg_sizes, arg_types,
 406                                    nullptr, nullptr, team_num, thread_limit);
 407 }
 408
 409 EXTERN int __tgt_target_teams_nowait(int64_t device_id, void *host_ptr,
 410     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
 411     int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
 412     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
 413   TIMESCOPE();
 414   if (depNum + noAliasDepNum > 0)
 415     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 416
 417   return __tgt_target_teams_mapper(nullptr, device_id, host_ptr, arg_num,
 418                                    args_base, args, arg_sizes, arg_types,
 419                                    nullptr, nullptr, team_num, thread_limit);
 420 }
 421
 422 EXTERN int __tgt_target_teams_mapper(ident_t *loc, int64_t device_id,
 423                                      void *host_ptr, int32_t arg_num,
 424                                      void **args_base, void **args,
 425                                      int64_t *arg_sizes, int64_t *arg_types,
 426                                      map_var_info_t *arg_names,
 427                                      void **arg_mappers, int32_t team_num,
 428                                      int32_t thread_limit) {
 429   TIMESCOPE();
 430   if (IsOffloadDisabled()) return OFFLOAD_FAIL;
 431   DP("Entering target region with entry point " DPxMOD " and device Id %"
 432       PRId64 "\n", DPxPTR(host_ptr), device_id);
 433
 434   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
 435     device_id = omp_get_default_device();
 436   }
 437
 438   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
 439     REPORT("Failed to get device %" PRId64 " ready\n", device_id);
 440     HandleTargetOutcome(false, loc);
 441     return OFFLOAD_FAIL;
 442   }
 443
 444   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
 445     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
 446                          arg_names, "Entering OpenMP kernel");
 447 #ifdef OMPTARGET_DEBUG
 448   for (int i=0; i<arg_num; ++i) {
 449     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
 450        ", Type=0x%" PRIx64 ", Name=%s\n",
 451        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
 452        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
 453   }
 454 #endif
 455
 456   int rc = target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
 457                   arg_types, arg_names, arg_mappers, team_num, thread_limit,
 458                   true /*team*/);
 459   HandleTargetOutcome(rc == OFFLOAD_SUCCESS, loc);
 460   return rc;
 461 }
 462
 463 EXTERN int __tgt_target_teams_nowait_mapper(
 464     ident_t *loc, int64_t device_id, void *host_ptr, int32_t arg_num,
 465     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
 466     map_var_info_t *arg_names, void **arg_mappers, int32_t team_num,
 467     int32_t thread_limit, int32_t depNum, void *depList, int32_t noAliasDepNum,
 468     void *noAliasDepList) {
 469   TIMESCOPE();
 470   if (depNum + noAliasDepNum > 0)
 471     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 472
 473   return __tgt_target_teams_mapper(loc, device_id, host_ptr, arg_num, args_base,
 474                                    args, arg_sizes, arg_types, arg_names,
 475                                    arg_mappers, team_num, thread_limit);
 476 }
 477
 478 // Get the current number of components for a user-defined mapper.
 479 EXTERN int64_t __tgt_mapper_num_components(void *rt_mapper_handle) {
 480   TIMESCOPE();
 481   auto *MapperComponentsPtr = (struct MapperComponentsTy *)rt_mapper_handle;
 482   int64_t size = MapperComponentsPtr->Components.size();
 483   DP("__tgt_mapper_num_components(Handle=" DPxMOD ") returns %" PRId64 "\n",
 484      DPxPTR(rt_mapper_handle), size);
 485   return size;
 486 }
 487
 488 // Push back one component for a user-defined mapper.
 489 EXTERN void __tgt_push_mapper_component(void *rt_mapper_handle, void *base,
 490                                         void *begin, int64_t size, int64_t type,
 491                                         void *name) {
 492   TIMESCOPE();
 493   DP("__tgt_push_mapper_component(Handle=" DPxMOD
 494      ") adds an entry (Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
 495      ", Type=0x%" PRIx64 ", Name=%s).\n",
 496      DPxPTR(rt_mapper_handle), DPxPTR(base), DPxPTR(begin), size, type,
 497      (name) ? getNameFromMapping(name).c_str() : "unknown");
 498   auto *MapperComponentsPtr = (struct MapperComponentsTy *)rt_mapper_handle;
 499   MapperComponentsPtr->Components.push_back(
 500       MapComponentInfoTy(base, begin, size, type, name));
 501 }
 502
 503 EXTERN void __kmpc_push_target_tripcount(ident_t *loc, int64_t device_id,
 504                                          uint64_t loop_tripcount) {
 505   TIMESCOPE();
 506   if (IsOffloadDisabled())
 507     return;
 508
 509   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
 510     device_id = omp_get_default_device();
 511   }
 512
 513   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
 514     DP("Failed to get device %" PRId64 " ready\n", device_id);
 515     HandleTargetOutcome(false, loc);
 516     return;
 517   }
 518
 519   DP("__kmpc_push_target_tripcount(%" PRId64 ", %" PRIu64 ")\n", device_id,
 520       loop_tripcount);
 521   PM->TblMapMtx.lock();
 522   PM->Devices[device_id].LoopTripCnt.emplace(__kmpc_global_thread_num(NULL),
 523                                              loop_tripcount);
 524   PM->TblMapMtx.unlock();
 525 }