[OpenMP] Avoid calling `isSPMDMode` during RT initialization

[jdoerfert]

Summary

Until we hit the first barrier we should not call mapping::isSPMDMode
with all threads. Instead, we now have (and use during initialization) a
mapping::isMainThreadInGenericMode overload that takes the known
SPMD-mode state and one that queries it.

openmp/libomptarget/DeviceRTL/include/Mapping.h

 /// Return true if the kernel is executed in SPMD mode.
 bool isSPMDMode();
 
 /// Return true if the kernel is executed in generic mode.
 bool isGenericMode();
 
 /// Return true if the executing thread is the main thread in generic mode.
 bool isMainThreadInGenericMode();
+bool isMainThreadInGenericMode(bool IsSPMD);
 
 /// Return true if the executing thread has the lowest Id of the active threads
 /// in the warp.
 bool isLeaderInWarp();
 
 /// Return a mask describing all active threads in the warp.
 LaneMaskTy activemask();
 

openmp/libomptarget/DeviceRTL/src/Kernel.cpp

if (IsSPMD) {
     // code and workers will run into a barrier right away.
   }
 
   if (IsSPMD) {
     state::assumeInitialState(IsSPMD);
     return -1;
   }
 
-  if (mapping::isMainThreadInGenericMode())
+  if (mapping::isMainThreadInGenericMode(IsSPMD))
     return -1;
 
   if (UseGenericStateMachine)
     genericStateMachine(Ident);
 
   return mapping::getThreadIdInBlock();
 }
 

openmp/libomptarget/DeviceRTL/src/Mapping.cpp

 
 } // namespace impl
 } // namespace _OMP
 
 /// We have to be deliberate about the distinction of `mapping::` and `impl::`
 /// below to avoid repeating assumptions or including irrelevant ones.
 ///{
 
-bool mapping::isMainThreadInGenericMode() {
-  if (mapping::isSPMDMode())
+bool mapping::isMainThreadInGenericMode(bool IsSPMD) {
+  if (IsSPMD)
     return false;
 
   // Check if this is the last warp in the block.
   uint32_t MainTId = (mapping::getNumberOfProcessorElements() - 1) &
                      ~(mapping::getWarpSize() - 1);
   return mapping::getThreadIdInBlock() == MainTId;
 }
 
+bool mapping::isMainThreadInGenericMode() {
+  return mapping::isMainThreadInGenericMode(mapping::isSPMDMode());
+}
+
 bool mapping::isLeaderInWarp() {
   __kmpc_impl_lanemask_t Active = mapping::activemask();
   __kmpc_impl_lanemask_t LaneMaskLT = mapping::lanemaskLT();
   return utils::popc(Active & LaneMaskLT) == 0;
 }
 
 LaneMaskTy mapping::activemask() { return impl::activemask(); }
 

openmp/libomptarget/DeviceRTL/src/Reduction.cpp

int32_t __kmpc_nvptx_teams_reduce_nowait_v2(
   // In non-generic mode all workers participate in the teams reduction.
   // In generic mode only the team master participates in the teams
   // reduction because the workers are waiting for parallel work.
   uint32_t ThreadId = mapping::getThreadIdInBlock();
   uint32_t TeamId = mapping::getBlockId();
   uint32_t NumTeams = mapping::getNumberOfBlocks();
   uint32_t NumThreads = mapping::getBlockSize();
   if (mapping::isGenericMode()) {
-    if (!mapping::isMainThreadInGenericMode())
+    if (!mapping::isMainThreadInGenericMode(/* IsSPMD */ false))
       return 0;
     ThreadId = 0;
     NumThreads = /* main thread only */ 1;
   }
 
   static unsigned SHARED(Bound);
   static unsigned SHARED(ChunkTeamCount);