[OpenMP][Offloading] Calculate offset in libomptarget

[tianshilei1992]

Summary

When invoking a kernel function, we pass arguments and offsets to plugin for now.
In each plugin, it recalculates the real argument by adding offsets to arguments.
We can actually move this part to libomptarget.

[grokos]

We need to keep bases and offsets separate. Sometimes (e.g. in OpenCL) we need to manifest base pointers prior to launching a kernel. Even if you have mapped an object only partially, e.g. A[N:M], although the kernel is expected to access elements starting at address &A[N] and beyond, we still need to manifest the base of the array &A[0]. In other cases, e.g. the COI API, need the begin address itself, i.e. &A[N] as the API operates on begin addresses, not bases. That's why we pass args and offsets as two separate entities so that each plugin can do what it needs. What you are trying to do with this patch is to revert https://reviews.llvm.org/D33028.

[tianshilei1992]

In D112490#3085810, @grokos wrote:

We need to keep bases and offsets separate. Sometimes (e.g. in OpenCL) we need to manifest base pointers prior to launching a kernel. Even if you have mapped an object only partially, e.g. A[N:M], although the kernel is expected to access elements starting at address &A[N] and beyond, we still need to manifest the base of the array &A[0]. That's why we pass args and offsets as two separate entities. What you are trying to do with this patch is to revert https://reviews.llvm.org/D33028.

I see. Thanks for the information. We don't support the case you mentioned in current repo, right? I did check all uses of the offsets in current repo, but looks like they just add them up everywhere.

[grokos]

In D112490#3085835, @tianshilei1992 wrote:

I see. Thanks for the information. We don't support the case you mentioned in current repo, right? I did check all uses of the offsets in current repo, but looks like they just add them up everywhere.

That's right, every plugin we currently have in the open-source repo operates on bases, that's why it's not clear why we separated args and offsets a few years ago. Maybe we should add a comment in the code pointing to D33028 to keep things clear.

openmp/libomptarget/plugins/amdgpu/src/rtl.cpp

int32_t __tgt_rtl_run_target_team_region_locked(
   // Set the context we are using
   // update thread limit content in gpu memory if un-initialized or specified
   // from host
 
   DP("Run target team region thread_limit %d\n", thread_limit);
 
   // All args are references.
   std::vector<void *> args(arg_num);
-  std::vector<void *> ptrs(arg_num);
 
   DP("Arg_num: %d\n", arg_num);
   for (int32_t i = 0; i < arg_num; ++i) {
-    ptrs[i] = (void *)((intptr_t)tgt_args[i] + tgt_offsets[i]);
-    args[i] = &ptrs[i];
-    DP("Offseted base: arg[%d]:" DPxMOD "\n", i, DPxPTR(ptrs[i]));
+    args[i] = &tgt_args[i];
+    DP("Offseted base: arg[%d]:" DPxMOD "\n", i, DPxPTR(tgt_args[i]));
   }
 
   KernelTy *KernelInfo = (KernelTy *)tgt_entry_ptr;
 
   std::string kernel_name = std::string(KernelInfo->Name);
   auto &KernelInfoTable = DeviceInfo.KernelInfoTable;
   if (KernelInfoTable[device_id].find(kernel_name) ==
       KernelInfoTable[device_id].end()) {

openmp/libomptarget/plugins/cuda/src/rtl.cpp

int runTargetTeamRegion(const int DeviceId, void *TgtEntryPtr, void **TgtArgs,
                           const unsigned int LoopTripCount,
                           __tgt_async_info *AsyncInfo) const {
     CUresult Err = cuCtxSetCurrent(DeviceData[DeviceId].Context);
     if (!checkResult(Err, "Error returned from cuCtxSetCurrent\n"))
       return OFFLOAD_FAIL;
 
     // All args are references.
     std::vector<void *> Args(ArgNum);
-    std::vector<void *> Ptrs(ArgNum);
-
-    for (int I = 0; I < ArgNum; ++I) {
-      Ptrs[I] = (void *)((intptr_t)TgtArgs[I] + TgtOffsets[I]);
-      Args[I] = &Ptrs[I];
-    }
+    for (int I = 0; I < ArgNum; ++I)
+      Args[I] = &TgtArgs[I];
 
     KernelTy *KernelInfo = reinterpret_cast<KernelTy *>(TgtEntryPtr);
 
     const bool IsSPMDGenericMode =
         KernelInfo->ExecutionMode == llvm::omp::OMP_TGT_EXEC_MODE_GENERIC_SPMD;
     const bool IsSPMDMode =
         KernelInfo->ExecutionMode == llvm::omp::OMP_TGT_EXEC_MODE_SPMD;
     const bool IsGenericMode =

openmp/libomptarget/plugins/generic-elf-64bit/src/rtl.cpp

int32_t __tgt_rtl_run_target_team_region(int32_t device_id, void *tgt_entry_ptr,
   // ignore team num and thread limit.
 
   // Use libffi to launch execution.
   ffi_cif cif;
 
   // All args are references.
   std::vector<ffi_type *> args_types(arg_num, &ffi_type_pointer);
   std::vector<void *> args(arg_num);
-  std::vector<void *> ptrs(arg_num);
 
-  for (int32_t i = 0; i < arg_num; ++i) {
-    ptrs[i] = (void *)((intptr_t)tgt_args[i] + tgt_offsets[i]);
-    args[i] = &ptrs[i];
-  }
+  for (int32_t i = 0; i < arg_num; ++i)
+    args[i] = &tgt_args[i];
 
   ffi_status status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, arg_num,
                                    &ffi_type_void, &args_types[0]);
 
   assert(status == FFI_OK && "Unable to prepare target launch!");
 
   if (status != FFI_OK)
     return OFFLOAD_FAIL;

openmp/libomptarget/plugins/remote/src/Client.cpp

return remoteCall(
         Request->set_tgt_entry_ptr(
             (uint64_t)RemoteEntries[DeviceId][TgtEntryPtr]);
 
         char **ArgPtr = (char **)TgtArgs;
         for (auto I = 0; I < ArgNum; I++, ArgPtr++) {
           Request->add_tgt_args((uint64_t)*ArgPtr);
         }
 
-        char *OffsetPtr = (char *)TgtOffsets;
-        for (auto I = 0; I < ArgNum; I++, OffsetPtr++)
-          Request->add_tgt_offsets((uint64_t)*OffsetPtr);
-
         Request->set_arg_num(ArgNum);
         Request->set_team_num(TeamNum);
         Request->set_thread_limit(ThreadLimit);
         Request->set_loop_tripcount(LoopTripcount);
 
         RPCStatus = Stub->RunTargetTeamRegion(&Context, *Request, Reply);
         return Reply;
       },

openmp/libomptarget/src/omptarget.cpp

__tgt_target_table *TargetTable = nullptr;
     std::lock_guard<std::mutex> TrlTblLock(PM->TrlTblMtx);
     assert(TM->Table->TargetsTable.size() > (size_t)DeviceId &&
            "Not expecting a device ID outside the table's bounds!");
     TargetTable = TM->Table->TargetsTable[DeviceId];
   }
   assert(TargetTable && "Global data has not been mapped\n");
 
   std::vector<void *> TgtArgs;
-  std::vector<ptrdiff_t> TgtOffsets;
-
   PrivateArgumentManagerTy PrivateArgumentManager(Device, AsyncInfo);
 
   int Ret;
   if (ArgNum) {
+    std::vector<ptrdiff_t> TgtOffsets;
     // Process data, such as data mapping, before launching the kernel
     Ret = processDataBefore(loc, DeviceId, HostPtr, ArgNum, ArgBases, Args,
                             ArgSizes, ArgTypes, ArgNames, ArgMappers, TgtArgs,
                             TgtOffsets, PrivateArgumentManager, AsyncInfo);
     if (Ret != OFFLOAD_SUCCESS) {
       REPORT("Failed to process data before launching the kernel.\n");
       return OFFLOAD_FAIL;
     }
+
+    for (int I = 0; I < TgtArgs.size(); ++I)
+      TgtArgs[I] = (void *)((intptr_t)TgtArgs[I] + TgtOffsets[I]);
   }
 
   // Get loop trip count
   uint64_t LoopTripCount = getLoopTripCount(DeviceId);
 
   // Launch device execution.
   void *TgtEntryPtr = TargetTable->EntriesBegin[TM->Index].addr;
   DP("Launching target execution %s with pointer " DPxMOD " (index=%d).\n",
      TargetTable->EntriesBegin[TM->Index].name, DPxPTR(TgtEntryPtr), TM->Index);
 
   {
     TIMESCOPE_WITH_NAME_AND_IDENT(
         IsTeamConstruct ? "runTargetTeamRegion" : "runTargetRegion", loc);
     if (IsTeamConstruct)
-      Ret = Device.runTeamRegion(TgtEntryPtr, &TgtArgs[0], &TgtOffsets[0],
-                                 TgtArgs.size(), TeamNum, ThreadLimit,
-                                 LoopTripCount, AsyncInfo);
+      Ret = Device.runTeamRegion(
+          TgtEntryPtr, &TgtArgs[0], nullptr /* TgtOffsets */, TgtArgs.size(),
+          TeamNum, ThreadLimit, LoopTripCount, AsyncInfo);
     else
-      Ret = Device.runRegion(TgtEntryPtr, &TgtArgs[0], &TgtOffsets[0],
+      Ret = Device.runRegion(TgtEntryPtr, &TgtArgs[0], nullptr /* TgtOffsets */,
                              TgtArgs.size(), AsyncInfo);
   }
 
   if (Ret != OFFLOAD_SUCCESS) {
     REPORT("Executing target region abort target.\n");
     return OFFLOAD_FAIL;
   }