[libomptarget][nfc] Extract function from data_sharing, move to common

[JonChesterfield]

Summary

[libomptarget][nfc] Extract function from data_sharing, move to common

Finding the first active thread in the warp is different on nvptx and amdgcn,
mostly due to warp size and the desire for efficiency.

[jdoerfert]

LGTM.

openmp/libomptarget/deviceRTLs/amdgcn/CMakeLists.txt

 
 get_filename_component(devicertl_base_directory
   ${CMAKE_CURRENT_SOURCE_DIR}
   DIRECTORY)
 
 set(cuda_sources
   ${devicertl_base_directory}/common/src/cancel.cu
   ${devicertl_base_directory}/common/src/critical.cu
-  ${devicertl_base_directory}/common/src/loop.cu
+  ${devicertl_base_directory}/common/src/data_sharing.cu
   ${devicertl_base_directory}/common/src/libcall.cu
-  ${devicertl_base_directory}/common/src/reduction.cu
+  ${devicertl_base_directory}/common/src/loop.cu
   ${devicertl_base_directory}/common/src/omp_data.cu
   ${devicertl_base_directory}/common/src/omptarget.cu
   ${devicertl_base_directory}/common/src/parallel.cu
+  ${devicertl_base_directory}/common/src/reduction.cu
   ${devicertl_base_directory}/common/src/sync.cu
   ${devicertl_base_directory}/common/src/task.cu)
 
 set(h_files
   ${CMAKE_CURRENT_SOURCE_DIR}/src/amdgcn_interface.h
   ${CMAKE_CURRENT_SOURCE_DIR}/src/hip_atomics.h
   ${CMAKE_CURRENT_SOURCE_DIR}/src/target_impl.h
   ${devicertl_base_directory}/common/debug.h

openmp/libomptarget/deviceRTLs/amdgcn/src/target_impl.h

 INLINE __kmpc_impl_lanemask_t __kmpc_impl_lanemask_lt() {
   return __lanemask_lt();
 }
 
 INLINE __kmpc_impl_lanemask_t __kmpc_impl_lanemask_gt() {
   return __lanemask_gt();
 }
 
+EXTERN bool __kmpc_impl_is_first_active_thread();
+
 INLINE uint32_t __kmpc_impl_smid() {
   return __smid();
 }
 
 INLINE double __target_impl_get_wtick() { return ((double)1E-9); }
 
 EXTERN int64_t __clock64();
 INLINE double __target_impl_get_wtime() {

openmp/libomptarget/deviceRTLs/common/src/data_sharing.cu

-//===----- data_sharing.cu - NVPTX OpenMP debug utilities -------- CUDA -*-===//
+//===----- data_sharing.cu - OpenMP GPU data sharing ------------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains the implementation of data sharing environments/
+// This file contains the implementation of data sharing environments
 //
 //===----------------------------------------------------------------------===//
 #include "common/omptarget.h"
 #include "target_impl.h"
 #include <stdio.h>
 
-// Return true if this is the first active thread in the warp.
-INLINE static bool IsWarpMasterActiveThread() {
-  unsigned long long Mask = __kmpc_impl_activemask();
-  unsigned long long ShNum = WARPSIZE - (GetThreadIdInBlock() % WARPSIZE);
-  unsigned long long Sh = Mask << ShNum;
-  // Truncate Sh to the 32 lower bits
-  return (unsigned)Sh == 0;
-}
 // Return true if this is the master thread.
 INLINE static bool IsMasterThread(bool isSPMDExecutionMode) {
   return !isSPMDExecutionMode && GetMasterThreadID() == GetThreadIdInBlock();
 }
 
 /// Return the provided size aligned to the size of a pointer.
 INLINE static size_t AlignVal(size_t Val) {
   const size_t Align = (size_t)sizeof(void *);
EXTERN void *__kmpc_data_sharing_environment_begin(
 
   DSPRINT(DSFLAG, "Warp ID: %u\n", WID);
   DSPRINT(DSFLAG, "Saved slot ptr at: %016llx \n", (unsigned long long)SlotP);
   DSPRINT(DSFLAG, "Saved stack ptr at: %016llx \n", (unsigned long long)StackP);
   DSPRINT(DSFLAG, "Saved frame ptr at: %016llx \n", (long long)FrameP);
   DSPRINT(DSFLAG, "Active threads: %08x \n", (unsigned)ActiveT);
 
   // Only the warp active master needs to grow the stack.
-  if (IsWarpMasterActiveThread()) {
+  if (__kmpc_impl_is_first_active_thread()) {
     // Save the current active threads.
     ActiveT = CurActiveThreads;
 
     // Make sure we use aligned sizes to avoid rematerialization of data.
     SharingDataSize = AlignVal(SharingDataSize);
     // FIXME: The default data size can be assumed to be aligned?
     SharingDefaultDataSize = AlignVal(SharingDefaultDataSize);
 
EXTERN void __kmpc_data_sharing_environment_end(
     void **SavedSharedFrame, __kmpc_impl_lanemask_t *SavedActiveThreads,
     int32_t IsEntryPoint) {
 
   DSPRINT0(DSFLAG, "Entering __kmpc_data_sharing_environment_end\n");
 
   unsigned WID = GetWarpId();
 
   if (IsEntryPoint) {
-    if (IsWarpMasterActiveThread()) {
+    if (__kmpc_impl_is_first_active_thread()) {
       DSPRINT0(DSFLAG, "Doing clean up\n");
 
       // The master thread cleans the saved slot, because this is an environment
       // only for the master.
       __kmpc_data_sharing_slot *S = IsMasterThread(isSPMDMode())
                                         ? *SavedSharedSlot
                                         : DataSharingState.SlotPtr[WID];
 
EXTERN void __kmpc_data_sharing_environment_end(
 
   __kmpc_impl_lanemask_t CurActive = __kmpc_impl_activemask();
 
   // Only the warp master can restore the stack and frame information, and only
   // if there are no other threads left behind in this environment (i.e. the
   // warp diverged and returns in different places). This only works if we
   // assume that threads will converge right after the call site that started
   // the environment.
-  if (IsWarpMasterActiveThread()) {
+  if (__kmpc_impl_is_first_active_thread()) {
     __kmpc_impl_lanemask_t &ActiveT = DataSharingState.ActiveThreads[WID];
 
     DSPRINT0(DSFLAG, "Before restoring the stack\n");
     // Zero the bits in the mask. If it is still different from zero, then we
     // have other threads that will return after the current ones.
     ActiveT &= ~CurActive;
 
     DSPRINT(DSFLAG, "Active threads: %08x; New mask: %08x\n",

openmp/libomptarget/deviceRTLs/nvptx/CMakeLists.txt

if(LIBOMPTARGET_DEP_CUDA_FOUND)
 
   # We really don't have any host code, so we don't need to care about
   # propagating host flags.
   set(CUDA_PROPAGATE_HOST_FLAGS OFF)
 
   set(cuda_src_files
       ${devicertl_common_directory}/src/cancel.cu
       ${devicertl_common_directory}/src/critical.cu
-      src/data_sharing.cu
+      ${devicertl_common_directory}/src/data_sharing.cu
       ${devicertl_common_directory}/src/libcall.cu
-      src/target_impl.cu
       ${devicertl_common_directory}/src/loop.cu
       ${devicertl_common_directory}/src/omptarget.cu
       ${devicertl_common_directory}/src/parallel.cu
       ${devicertl_common_directory}/src/reduction.cu
       ${devicertl_common_directory}/src/support.cu
       ${devicertl_common_directory}/src/sync.cu
       ${devicertl_common_directory}/src/task.cu
+      src/target_impl.cu
   )
 
   set(omp_data_objects ${devicertl_common_directory}/src/omp_data.cu)
 
   # Get the compute capability the user requested or use SM_35 by default.
   # SM_35 is what clang uses by default.
   set(default_capabilities 35)
   if (DEFINED LIBOMPTARGET_NVPTX_COMPUTE_CAPABILITY)

openmp/libomptarget/deviceRTLs/nvptx/src/target_impl.h

 }
 
 INLINE __kmpc_impl_lanemask_t __kmpc_impl_lanemask_gt() {
   __kmpc_impl_lanemask_t res;
   asm("mov.u32 %0, %%lanemask_gt;" : "=r"(res));
   return res;
 }
 
+// Return true if this is the first active thread in the warp.
+INLINE bool __kmpc_impl_is_first_active_thread() {
+  unsigned long long Mask = __kmpc_impl_activemask();
+  unsigned long long ShNum = WARPSIZE - (GetThreadIdInBlock() % WARPSIZE);
+  unsigned long long Sh = Mask << ShNum;
+  // Truncate Sh to the 32 lower bits
+  return (unsigned)Sh == 0;
+}
+
 INLINE uint32_t __kmpc_impl_smid() {
   uint32_t id;
   asm("mov.u32 %0, %%smid;" : "=r"(id));
   return id;
 }
 
 INLINE double __target_impl_get_wtick() {
   // Timer precision is 1ns