[Clang][OpenMP] New clang/libomptarget map interface: new function signatures, libomptarget-side

[grokos]

Summary

This is the complementary libomptarget patch which changes the __tgt_* API function signatures in preparation for the new map interface.

Changes are:

1. Device IDs 32bits --> 64bits
2. Flags 32bits --> 64bits

Clang patch: D40281

[Hahnfeld]

LGTM

openmp/trunk/libomptarget/src/omptarget.h

 void __tgt_register_lib(__tgt_bin_desc *desc);
 
 /// removes a target shared library from the target execution image
 void __tgt_unregister_lib(__tgt_bin_desc *desc);
 
 // creates the host to target data mapping, stores it in the
 // libomptarget.so internal structure (an entry in a stack of data maps) and
 // passes the data to the device;
-void __tgt_target_data_begin(int32_t device_id, int32_t arg_num,
+void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
                              void **args_base, void **args, int64_t *arg_sizes,
-                             int32_t *arg_types);
-void __tgt_target_data_begin_nowait(int32_t device_id, int32_t arg_num,
+                             int64_t *arg_types);
+void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
                                     void **args_base, void **args,
-                                    int64_t *arg_sizes, int32_t *arg_types,
+                                    int64_t *arg_sizes, int64_t *arg_types,
                                     int32_t depNum, void *depList,
                                     int32_t noAliasDepNum,
                                     void *noAliasDepList);
 
 // passes data from the target, release target memory and destroys the
 // host-target mapping (top entry from the stack of data maps) created by
 // the last __tgt_target_data_begin
-void __tgt_target_data_end(int32_t device_id, int32_t arg_num, void **args_base,
-                           void **args, int64_t *arg_sizes, int32_t *arg_types);
-void __tgt_target_data_end_nowait(int32_t device_id, int32_t arg_num,
+void __tgt_target_data_end(int64_t device_id, int32_t arg_num, void **args_base,
+                           void **args, int64_t *arg_sizes, int64_t *arg_types);
+void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
                                   void **args_base, void **args,
-                                  int64_t *arg_sizes, int32_t *arg_types,
+                                  int64_t *arg_sizes, int64_t *arg_types,
                                   int32_t depNum, void *depList,
                                   int32_t noAliasDepNum, void *noAliasDepList);
 
 /// passes data to/from the target
-void __tgt_target_data_update(int32_t device_id, int32_t arg_num,
+void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
                               void **args_base, void **args, int64_t *arg_sizes,
-                              int32_t *arg_types);
-void __tgt_target_data_update_nowait(int32_t device_id, int32_t arg_num,
+                              int64_t *arg_types);
+void __tgt_target_data_update_nowait(int64_t device_id, int32_t arg_num,
                                      void **args_base, void **args,
-                                     int64_t *arg_sizes, int32_t *arg_types,
+                                     int64_t *arg_sizes, int64_t *arg_types,
                                      int32_t depNum, void *depList,
                                      int32_t noAliasDepNum,
                                      void *noAliasDepList);
 
 // Performs the same actions as data_begin in case arg_num is non-zero
 // and initiates run of offloaded region on target platform; if arg_num
 // is non-zero after the region execution is done it also performs the
 // same action as data_end above. The following types are used; this
 // function returns 0 if it was able to transfer the execution to a
 // target and an int different from zero otherwise.
-int __tgt_target(int32_t device_id, void *host_ptr, int32_t arg_num,
+int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
                  void **args_base, void **args, int64_t *arg_sizes,
-                 int32_t *arg_types);
-int __tgt_target_nowait(int32_t device_id, void *host_ptr, int32_t arg_num,
+                 int64_t *arg_types);
+int __tgt_target_nowait(int64_t device_id, void *host_ptr, int32_t arg_num,
                         void **args_base, void **args, int64_t *arg_sizes,
-                        int32_t *arg_types, int32_t depNum, void *depList,
+                        int64_t *arg_types, int32_t depNum, void *depList,
                         int32_t noAliasDepNum, void *noAliasDepList);
 
-int __tgt_target_teams(int32_t device_id, void *host_ptr, int32_t arg_num,
+int __tgt_target_teams(int64_t device_id, void *host_ptr, int32_t arg_num,
                        void **args_base, void **args, int64_t *arg_sizes,
-                       int32_t *arg_types, int32_t num_teams,
+                       int64_t *arg_types, int32_t num_teams,
                        int32_t thread_limit);
-int __tgt_target_teams_nowait(int32_t device_id, void *host_ptr,
+int __tgt_target_teams_nowait(int64_t device_id, void *host_ptr,
                               int32_t arg_num, void **args_base, void **args,
-                              int64_t *arg_sizes, int32_t *arg_types,
+                              int64_t *arg_sizes, int64_t *arg_types,
                               int32_t num_teams, int32_t thread_limit,
                               int32_t depNum, void *depList,
                               int32_t noAliasDepNum, void *noAliasDepList);
-void __kmpc_push_target_tripcount(int32_t device_id, uint64_t loop_tripcount);
+void __kmpc_push_target_tripcount(int64_t device_id, uint64_t loop_tripcount);
 
 #ifdef __cplusplus
 }
 #endif
 
 #ifdef OMPTARGET_DEBUG
 #include <stdio.h>
 #define DEBUGP(prefix, ...)                                                    \

openmp/trunk/libomptarget/src/omptarget.cpp

 static const char *RTLNames[] = {
     /* PowerPC target */ "libomptarget.rtl.ppc64.so",
     /* x86_64 target  */ "libomptarget.rtl.x86_64.so",
     /* CUDA target    */ "libomptarget.rtl.cuda.so",
     /* AArch64 target */ "libomptarget.rtl.aarch64.so"};
 
 // forward declarations
 struct RTLInfoTy;
-static int target(int32_t device_id, void *host_ptr, int32_t arg_num,
+static int target(int64_t device_id, void *host_ptr, int32_t arg_num,
     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
     int32_t team_num, int32_t thread_limit, int IsTeamConstruct);
 
 /// Map between host data and target data.
 struct HostDataToTargetTy {
   uintptr_t HstPtrBase; // host info.
   uintptr_t HstPtrBegin;
   uintptr_t HstPtrEnd; // non-inclusive.

 struct combined_entry_t {
   int num_members; // number of members in combined entry
   void *base_addr; // base address of combined entry
   void *begin_addr; // begin address of combined entry
   void *end_addr; // size of combined entry
 };
 
 static void translate_map(int32_t arg_num, void **args_base, void **args,
-    int64_t *arg_sizes, int32_t *arg_types, int32_t &new_arg_num,
+    int64_t *arg_sizes, int64_t *arg_types, int32_t &new_arg_num,
     void **&new_args_base, void **&new_args, int64_t *&new_arg_sizes,
     int64_t *&new_arg_types, bool is_target_construct) {
   if (arg_num <= 0) {
     DP("Nothing to translate\n");
     new_arg_num = 0;
     return;
   }
 
   // array of combined entries
   combined_entry_t *cmb_entries =
       (combined_entry_t *) alloca(arg_num * sizeof(combined_entry_t));
   // number of combined entries
   long num_combined = 0;
   // old entry is MAP_PTR?
   bool *is_ptr_old = (bool *) alloca(arg_num * sizeof(bool));
   // old entry is member of member_of[old] cmb_entry
   int *member_of = (int *) alloca(arg_num * sizeof(int));
   // temporary storage for modifications of the original arg_types
-  int32_t *mod_arg_types = (int32_t *) alloca(arg_num  *sizeof(int32_t));
+  int64_t *mod_arg_types = (int64_t *) alloca(arg_num  *sizeof(int64_t));
 
   DP("Translating %d map entries\n", arg_num);
   for (int i = 0; i < arg_num; ++i) {
     member_of[i] = -1;
     is_ptr_old[i] = false;
     mod_arg_types[i] = arg_types[i];
     // Scan previous entries to see whether this entry shares the same base
     for (int j = 0; j < i; ++j) {
if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ) {
           Pointer_TgtPtrBegin, TgtPtrBase};
       Device.ShadowMtx.unlock();
     }
   }
 
   return rc;
 }
 
-EXTERN void __tgt_target_data_begin_nowait(int32_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int32_t *arg_types,
+EXTERN void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
+    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
     int32_t depNum, void *depList, int32_t noAliasDepNum,
     void *noAliasDepList) {
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, 0);
 
   __tgt_target_data_begin(device_id, arg_num, args_base, args, arg_sizes,
                           arg_types);
 }
 
 /// creates host-to-target data mapping, stores it in the
 /// libomptarget.so internal structure (an entry in a stack of data maps)
 /// and passes the data to the device.
-EXTERN void __tgt_target_data_begin(int32_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int32_t *arg_types) {
-  DP("Entering data begin region for device %d with %d mappings\n", device_id,
+EXTERN void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
+    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
+  DP("Entering data begin region for device %ld with %d mappings\n", device_id,
      arg_num);
 
   // No devices available?
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
-    DP("Use default device id %d\n", device_id);
+    DP("Use default device id %ld\n", device_id);
   }
 
   if (CheckDevice(device_id) != OFFLOAD_SUCCESS) {
-    DP("Failed to get device %d ready\n", device_id);
+    DP("Failed to get device %ld ready\n", device_id);
     return;
   }
 
   DeviceTy& Device = Devices[device_id];
 
   // Translate maps
   int32_t new_arg_num;
   void **new_args_base;
static int target_data_end(DeviceTy &Device, int32_t arg_num, void **args_base,
   }
 
   return rc;
 }
 
 /// passes data from the target, releases target memory and destroys
 /// the host-target mapping (top entry from the stack of data maps)
 /// created by the last __tgt_target_data_begin.
-EXTERN void __tgt_target_data_end(int32_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int32_t *arg_types) {
+EXTERN void __tgt_target_data_end(int64_t device_id, int32_t arg_num,
+    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
   DP("Entering data end region with %d mappings\n", arg_num);
 
   // No devices available?
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   RTLsMtx.lock();
   size_t Devices_size = Devices.size();
   RTLsMtx.unlock();
   if (Devices_size <= (size_t)device_id) {
-    DP("Device ID  %d does not have a matching RTL.\n", device_id);
+    DP("Device ID  %ld does not have a matching RTL.\n", device_id);
     return;
   }
 
   DeviceTy &Device = Devices[device_id];
   if (!Device.IsInit) {
     DP("uninit device: ignore");
     return;
   }
EXTERN void __tgt_target_data_end(int64_t device_id, int32_t arg_num,
   target_data_end(Device, new_arg_num, new_args_base, new_args, new_arg_sizes,
       new_arg_types);
 
   // Cleanup translation memory
   cleanup_map(new_arg_num, new_args_base, new_args, new_arg_sizes,
       new_arg_types, arg_num, args_base);
 }
 
-EXTERN void __tgt_target_data_end_nowait(int32_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int32_t *arg_types,
+EXTERN void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
+    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
     int32_t depNum, void *depList, int32_t noAliasDepNum,
     void *noAliasDepList) {
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, 0);
 
   __tgt_target_data_end(device_id, arg_num, args_base, args, arg_sizes,
                         arg_types);
 }
 
 /// passes data to/from the target.
-EXTERN void __tgt_target_data_update(int32_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int32_t *arg_types) {
+EXTERN void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
+    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
   DP("Entering data update with %d mappings\n", arg_num);
 
   // No devices available?
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDevice(device_id) != OFFLOAD_SUCCESS) {
-    DP("Failed to get device %d ready\n", device_id);
+    DP("Failed to get device %ld ready\n", device_id);
     return;
   }
 
   DeviceTy& Device = Devices[device_id];
 
   // process each input.
   for (int32_t i = 0; i < arg_num; ++i) {
     if ((arg_types[i] & OMP_TGT_MAPTYPE_LITERAL) ||
if (arg_types[i] & OMP_TGT_MAPTYPE_TO) {
             &it->second.TgtPtrVal, sizeof(void *));
       }
       Device.ShadowMtx.unlock();
     }
   }
 }
 
 EXTERN void __tgt_target_data_update_nowait(
-    int32_t device_id, int32_t arg_num, void **args_base, void **args,
-    int64_t *arg_sizes, int32_t *arg_types, int32_t depNum, void *depList,
+    int64_t device_id, int32_t arg_num, void **args_base, void **args,
+    int64_t *arg_sizes, int64_t *arg_types, int32_t depNum, void *depList,
     int32_t noAliasDepNum, void *noAliasDepList) {
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, 0);
 
   __tgt_target_data_update(device_id, arg_num, args_base, args, arg_sizes,
                            arg_types);
 }
 
 /// performs the same actions as data_begin in case arg_num is
 /// non-zero and initiates run of the offloaded region on the target platform;
 /// if arg_num is non-zero after the region execution is done it also
 /// performs the same action as data_update and data_end above. This function
 /// returns 0 if it was able to transfer the execution to a target and an
 /// integer different from zero otherwise.
-static int target(int32_t device_id, void *host_ptr, int32_t arg_num,
+static int target(int64_t device_id, void *host_ptr, int32_t arg_num,
     void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
     int32_t team_num, int32_t thread_limit, int IsTeamConstruct) {
   DeviceTy &Device = Devices[device_id];
 
   // Find the table information in the map or look it up in the translation
   // tables.
   TableMap *TM = 0;
   TblMapMtx.lock();
#endif
   if (rt != OFFLOAD_SUCCESS) {
     DP("Call to target_data_end failed.\n");
     rc = OFFLOAD_FAIL;
   }
 
   return rc;
 }
 
-EXTERN int __tgt_target(int32_t device_id, void *host_ptr, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int32_t *arg_types) {
-  DP("Entering target region with entry point " DPxMOD " and device Id %d\n",
+EXTERN int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
+    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
+  DP("Entering target region with entry point " DPxMOD " and device Id %ld\n",
      DPxPTR(host_ptr), device_id);
 
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDevice(device_id) != OFFLOAD_SUCCESS) {
-    DP("Failed to get device %d ready\n", device_id);
+    DP("Failed to get device %ld ready\n", device_id);
     return OFFLOAD_FAIL;
   }
 
   // Translate maps
   int32_t new_arg_num;
   void **new_args_base;
   void **new_args;
   int64_t *new_arg_sizes;
   int64_t *new_arg_types;
   translate_map(arg_num, args_base, args, arg_sizes, arg_types, new_arg_num,
       new_args_base, new_args, new_arg_sizes, new_arg_types, true);
 
   //return target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
   //    arg_types, 0, 0, false /*team*/, false /*recursive*/);
   int rc = target(device_id, host_ptr, new_arg_num, new_args_base, new_args,
       new_arg_sizes, new_arg_types, 0, 0, false /*team*/);
 
   // Cleanup translation memory
   cleanup_map(new_arg_num, new_args_base, new_args, new_arg_sizes,
       new_arg_types, arg_num, args_base);
 
   return rc;
 }
 
-EXTERN int __tgt_target_nowait(int32_t device_id, void *host_ptr,
+EXTERN int __tgt_target_nowait(int64_t device_id, void *host_ptr,
     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
-    int32_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
+    int64_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
     void *noAliasDepList) {
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, 0);
 
   return __tgt_target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
                       arg_types);
 }
 
-EXTERN int __tgt_target_teams(int32_t device_id, void *host_ptr,
+EXTERN int __tgt_target_teams(int64_t device_id, void *host_ptr,
     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
-    int32_t *arg_types, int32_t team_num, int32_t thread_limit) {
-  DP("Entering target region with entry point " DPxMOD " and device Id %d\n",
+    int64_t *arg_types, int32_t team_num, int32_t thread_limit) {
+  DP("Entering target region with entry point " DPxMOD " and device Id %ld\n",
      DPxPTR(host_ptr), device_id);
 
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDevice(device_id) != OFFLOAD_SUCCESS) {
-    DP("Failed to get device %d ready\n", device_id);
+    DP("Failed to get device %ld ready\n", device_id);
     return OFFLOAD_FAIL;
   }
 
   // Translate maps
   int32_t new_arg_num;
   void **new_args_base;
   void **new_args;
   int64_t *new_arg_sizes;
EXTERN int __tgt_target_teams(int64_t device_id, void *host_ptr,
 
   // Cleanup translation memory
   cleanup_map(new_arg_num, new_args_base, new_args, new_arg_sizes,
       new_arg_types, arg_num, args_base);
 
   return rc;
 }
 
-EXTERN int __tgt_target_teams_nowait(int32_t device_id, void *host_ptr,
+EXTERN int __tgt_target_teams_nowait(int64_t device_id, void *host_ptr,
     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
-    int32_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
+    int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, 0);
 
   return __tgt_target_teams(device_id, host_ptr, arg_num, args_base, args,
                             arg_sizes, arg_types, team_num, thread_limit);
 }
 
 
 // The trip count mechanism will be revised - this scheme is not thread-safe.
-EXTERN void __kmpc_push_target_tripcount(int32_t device_id,
+EXTERN void __kmpc_push_target_tripcount(int64_t device_id,
     uint64_t loop_tripcount) {
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDevice(device_id) != OFFLOAD_SUCCESS) {
-    DP("Failed to get device %d ready\n", device_id);
+    DP("Failed to get device %ld ready\n", device_id);
     return;
   }
 
-  DP("__kmpc_push_target_tripcount(%d, %" PRIu64 ")\n", device_id,
+  DP("__kmpc_push_target_tripcount(%ld, %" PRIu64 ")\n", device_id,
       loop_tripcount);
   Devices[device_id].loopTripCnt = loop_tripcount;
 }