[libomptarget][nfc] Wrap cuda min() in target_impl

[JonChesterfield]

Summary

[libomptarget][nfc] Wrap cuda min() in target_impl

nvptx forwards to cuda min, amdgcn implements directly.
Sufficient to build parallel.cu for amdgcn, added to CMakeLists.

All call sites are homogenous except one that passes a uint32_t and an
int32_t. This could be smoothed over by taking two type parameters
and some care over the return type, but overall I think the inline
<uint32_t> calling attention to what was an implicit sign conversion
is cleaner.

[JonChesterfield]

openmp/libomptarget/deviceRTLs/nvptx/src/reduction.cu

483

Here, NumTeams is a uint32_t and num_of_records is an int32_t. I quite like the <> sigil calling attention to this, but am open to alternatives.

[jdoerfert]

LGTM. I proposed an alternative spelling for the one special case but I don't care much which you choose.

openmp/libomptarget/deviceRTLs/nvptx/src/reduction.cu

483

This is fine, __kmpc_impl_min(NumTeams, uint32_t(num_of_records)); would be an alternative to make clear what is casted.

[JonChesterfield]

• More explicit cast

[JonChesterfield]

openmp/libomptarget/deviceRTLs/nvptx/src/reduction.cu

483

I like that more, thanks

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/omptarget.cu
+  ${devicertl_base_directory}/common/src/parallel.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 uint32_t __kmpc_impl_smid() {
   return __smid();
 }
 
 INLINE uint64_t __kmpc_impl_ffs(uint64_t x) { return __builtin_ffsl(x); }
 
 INLINE uint64_t __kmpc_impl_popc(uint64_t x) { return __builtin_popcountl(x); }
 
+template <typename T> INLINE T __kmpc_impl_min(T x, T y) {
+  return x < y ? x : y;
+}
+
 INLINE __kmpc_impl_lanemask_t __kmpc_impl_activemask() {
   return __ballot64(1);
 }
 
 EXTERN int32_t __kmpc_impl_shfl_sync(__kmpc_impl_lanemask_t, int32_t Var,
                                      int32_t SrcLane);
 
 EXTERN int32_t __kmpc_impl_shfl_down_sync(__kmpc_impl_lanemask_t, int32_t Var,

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

EXTERN bool __kmpc_kernel_convergent_simd(void *buffer,
 
   int32_t SimdLimitSource = __kmpc_impl_shfl_sync(Mask, SimdLimit, *LaneSource);
   // reset simdlimit to avoid propagating to successive #simd
   if (SimdLimitSource > 0 && threadId == sourceThreadId)
     omptarget_nvptx_threadPrivateContext->SimdLimitForNextSimd(threadId) = 0;
 
   // We cannot have more than the # of convergent threads.
   if (SimdLimitSource > 0)
-    *NumLanes = min(ConvergentSize, SimdLimitSource);
+    *NumLanes = __kmpc_impl_min(ConvergentSize, SimdLimitSource);
   else
     *NumLanes = ConvergentSize;
   ASSERT(LT_FUSSY, *NumLanes > 0, "bad thread request of %d threads",
          (int)*NumLanes);
 
   // Set to true for lanes participating in the simd region.
   bool isActive = false;
   // Initialize state for active threads.
EXTERN bool __kmpc_kernel_convergent_parallel(void *buffer,
   // reset numthreads to avoid propagating to successive #parallel
   if (NumThreadsSource > 0 && threadId == sourceThreadId)
     omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(threadId) =
         0;
 
   // We cannot have more than the # of convergent threads.
   uint16_t NumThreads;
   if (NumThreadsSource > 0)
-    NumThreads = min(ConvergentSize, NumThreadsSource);
+    NumThreads = __kmpc_impl_min(ConvergentSize, NumThreadsSource);
   else
     NumThreads = ConvergentSize;
   ASSERT(LT_FUSSY, NumThreads > 0, "bad thread request of %d threads",
          (int)NumThreads);
 
   // Set to true for workers participating in the parallel region.
   bool isActive = false;
   // Initialize state for active threads.

openmp/libomptarget/deviceRTLs/nvptx/src/reduction.cu

EXTERN int32_t __kmpc_nvptx_teams_reduce_nowait_v2(
   // Each thread will have a local struct containing the values to be
   // reduced:
   //      1. do reduction within each warp.
   //      2. do reduction across warps.
   //      3. write the final result to the main reduction variable
   //         by returning 1 in the thread holding the reduction result.
 
   // Check if this is the very last team.
-  unsigned NumRecs = min(NumTeams, num_of_records);
+  unsigned NumRecs = __kmpc_impl_min(NumTeams, uint32_t(num_of_records));
   if (ChunkTeamCount == NumTeams - Bound - 1) {
     //
     // Last team processing.
     //
     if (ThreadId >= NumRecs)
       return 0;
-    NumThreads = roundToWarpsize(min(NumThreads, NumRecs));
+    NumThreads = roundToWarpsize(__kmpc_impl_min(NumThreads, NumRecs));
     if (ThreadId >= NumThreads)
       return 0;
 
     // Load from buffer and reduce.
     glcpyFct(global_buffer, ThreadId, reduce_data);
     for (uint32_t i = NumThreads + ThreadId; i < NumRecs; i += NumThreads)
       glredFct(global_buffer, i, reduce_data);
 
     // Reduce across warps to the warp master.
     if (NumThreads > 1) {
       gpu_regular_warp_reduce(reduce_data, shflFct);
 
       // When we have more than [warpsize] number of threads
       // a block reduction is performed here.
-      uint32_t ActiveThreads = min(NumRecs, NumThreads);
+      uint32_t ActiveThreads = __kmpc_impl_min(NumRecs, NumThreads);
       if (ActiveThreads > WARPSIZE) {
         uint32_t WarpsNeeded = (ActiveThreads + WARPSIZE - 1) / WARPSIZE;
         // Gather all the reduced values from each warp
         // to the first warp.
         cpyFct(reduce_data, WarpsNeeded);
 
         uint32_t WarpId = ThreadId / WARPSIZE;
         if (WarpId == 0)

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

INLINE uint32_t __kmpc_impl_smid() {
   asm("mov.u32 %0, %%smid;" : "=r"(id));
   return id;
 }
 
 INLINE uint32_t __kmpc_impl_ffs(uint32_t x) { return __ffs(x); }
 
 INLINE uint32_t __kmpc_impl_popc(uint32_t x) { return __popc(x); }
 
+template <typename T> INLINE T __kmpc_impl_min(T x, T y) {
+  return min(x, y);
+}
+
 #ifndef CUDA_VERSION
 #error CUDA_VERSION macro is undefined, something wrong with cuda.
 #endif
 
 // In Cuda 9.0, __ballot(1) from Cuda 8.0 is replaced with __activemask().
 
 INLINE __kmpc_impl_lanemask_t __kmpc_impl_activemask() {
 #if CUDA_VERSION >= 9000