[OpenMP][Offloading] Replace all calls to `isSPMDMode` with `__kmpc_is_spmd_exec_mode`

[tianshilei1992]

Summary

In our ongoing work, we are using AbstractAttributor to deduct execution model
of device functions, and potententially remove unnecessary function calls to
__kmpc_is_spmd_exec_mode. In current device runtime, we have mixed use of
isSPMDMode and __kmpc_is_spmd_exec_mode, but in fact in __kmpc_is_spmd_exec_mode
it simply calls isSPMDMode. Since all functions starting with __kmpc is C
function, which doesn't have things like name mangling. It is more optimization
friendly. In this patch, we simply replaced all calls to isSPMDMode with
__kmpc_is_spmd_exec_mode to pave the way for the optimization.

[jdoerfert]

If you replace isSPMDMode with __kmpc_is_spmd_exec_mode let's delete the former.

[tianshilei1992]

remove isSPMDMode completely

[JonChesterfield]

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

164–165

Ah, bad. This change introduces PRINT0 calls absolutely everywhere. That will make a mess.

My preference would be to delete this PRINT0 call.

If we can't do that, I guess we could still with one function called internally that doesn't print and one function called externally that does, but 'external' in this context is clang.

[tianshilei1992]

remove PRINT0

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

static void *__kmpc_alloc_for_warp(AllocTy Alloc, unsigned Bytes,
   FP[0] = __kmpc_impl_shfl_sync(CurActive, FP[0], LeaderID);
   if (sizeof(Ptr) == 8)
     FP[1] = __kmpc_impl_shfl_sync(CurActive, FP[1], LeaderID);
   return (void *)&((char *)(Ptr))[(GetLaneId() - LeaderID) * Bytes];
 }
 
 EXTERN void *__kmpc_alloc_shared(size_t Bytes) {
   Bytes = Bytes + (Bytes % MinBytes);
-  if (IsMasterThread(isSPMDMode())) {
+  if (IsMasterThread(__kmpc_is_spmd_exec_mode())) {
     // Main thread alone, use shared memory if space is available.
     if (MainSharedStack.Usage[0] + Bytes <= MainSharedStack.MaxSize) {
       void *Ptr = &MainSharedStack.Data[MainSharedStack.Usage[0]];
       MainSharedStack.Usage[0] += Bytes;
       MainSharedStack.Sizes[MainSharedStack.SizeUsage[0]++] = Bytes;
       return Ptr;
     }
   } else {

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

 EXTERN double omp_get_wtime(void) {
   double rc = __kmpc_impl_get_wtime();
   PRINT(LD_IO, "call omp_get_wtime() returns %g\n", rc);
   return rc;
 }
 
 EXTERN void omp_set_num_threads(int num) {
   // Ignore it for SPMD mode.
-  if (isSPMDMode())
+  if (__kmpc_is_spmd_exec_mode())
     return;
   ASSERT0(LT_FUSSY, isRuntimeInitialized(), "Expected initialized runtime.");
   PRINT(LD_IO, "call omp_set_num_threads(num %d)\n", num);
   if (num <= 0) {
     WARNING0(LW_INPUT, "expected positive num; ignore\n");
   } else if (parallelLevel[GetWarpId()] == 0) {
     nThreads = num;
   }
 }
 
 EXTERN int omp_get_num_threads(void) {
-  int rc = GetNumberOfOmpThreads(isSPMDMode());
+  int rc = GetNumberOfOmpThreads(__kmpc_is_spmd_exec_mode());
   PRINT(LD_IO, "call omp_get_num_threads() return %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_get_max_threads(void) {
   if (parallelLevel[GetWarpId()] > 0)
     // We're already in parallel region.
     return 1; // default is 1 thread avail
   // Not currently in a parallel region, return what was set.
   int rc = 1;
   if (parallelLevel[GetWarpId()] == 0)
     rc = nThreads;
   ASSERT0(LT_FUSSY, rc >= 0, "bad number of threads");
   PRINT(LD_IO, "call omp_get_max_threads() return %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_get_thread_limit(void) {
-  if (isSPMDMode())
+  if (__kmpc_is_spmd_exec_mode())
     return GetNumberOfThreadsInBlock();
   int rc = threadLimit;
   PRINT(LD_IO, "call omp_get_thread_limit() return %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_get_thread_num() {
-  bool isSPMDExecutionMode = isSPMDMode();
+  bool isSPMDExecutionMode = __kmpc_is_spmd_exec_mode();
   int tid = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
   int rc = GetOmpThreadId(tid, isSPMDExecutionMode);
   PRINT(LD_IO, "call omp_get_thread_num() returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_get_num_procs(void) {
-  int rc = GetNumberOfProcsInDevice(isSPMDMode());
+  int rc = GetNumberOfProcsInDevice(__kmpc_is_spmd_exec_mode());
   PRINT(LD_IO, "call omp_get_num_procs() returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_in_parallel(void) {
   int rc = parallelLevel[GetWarpId()] > OMP_ACTIVE_PARALLEL_LEVEL ? 1 : 0;
   PRINT(LD_IO, "call omp_in_parallel() returns %d\n", rc);
   return rc;

 
 EXTERN int omp_get_active_level(void) {
   int level = parallelLevel[GetWarpId()] > OMP_ACTIVE_PARALLEL_LEVEL ? 1 : 0;
   PRINT(LD_IO, "call omp_get_active_level() returns %d\n", level)
   return level;
 }
 
 EXTERN int omp_get_ancestor_thread_num(int level) {
-  if (isSPMDMode())
+  if (__kmpc_is_spmd_exec_mode())
     return level == 1 ? GetThreadIdInBlock() : 0;
   int rc = -1;
   // If level is 0 or all parallel regions are not active - return 0.
   unsigned parLevel = parallelLevel[GetWarpId()];
   if (level == 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL) {
     int totLevel = omp_get_level();
     if (level <= totLevel) {
       omptarget_nvptx_TaskDescr *currTaskDescr =
if (level == 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL) {
     rc = 0;
   }
   PRINT(LD_IO, "call omp_get_ancestor_thread_num(level %d) returns %d\n", level,
         rc)
   return rc;
 }
 
 EXTERN int omp_get_team_size(int level) {
-  if (isSPMDMode())
+  if (__kmpc_is_spmd_exec_mode())
     return level == 1 ? GetNumberOfThreadsInBlock() : 1;
   int rc = -1;
   unsigned parLevel = parallelLevel[GetWarpId()];
   // If level is 0 or all parallel regions are not active - return 1.
   if (level == 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL) {
     rc = threadsInTeam;
   } else if (level == 0 ||
              (level > 0 && parLevel < OMP_ACTIVE_PARALLEL_LEVEL &&
               level <= parLevel) ||
              (level > 1 && parLevel > OMP_ACTIVE_PARALLEL_LEVEL &&
               level <= (parLevel - OMP_ACTIVE_PARALLEL_LEVEL))) {
     rc = 1;
   }
   PRINT(LD_IO, "call omp_get_team_size(level %d) returns %d\n", level, rc)
   return rc;
 }
 
 EXTERN void omp_get_schedule(omp_sched_t *kind, int *modifier) {
   if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
+    ASSERT0(LT_FUSSY, __kmpc_is_spmd_exec_mode(),
             "Expected SPMD mode only with uninitialized runtime.");
     *kind = omp_sched_static;
     *modifier = 1;
   } else {
     omptarget_nvptx_TaskDescr *currTaskDescr =
-        getMyTopTaskDescriptor(isSPMDMode());
+        getMyTopTaskDescriptor(__kmpc_is_spmd_exec_mode());
     *kind = currTaskDescr->GetRuntimeSched();
     *modifier = currTaskDescr->RuntimeChunkSize();
   }
   PRINT(LD_IO, "call omp_get_schedule returns sched %d and modif %d\n",
         (int)*kind, *modifier);
 }
 
 EXTERN void omp_set_schedule(omp_sched_t kind, int modifier) {
   PRINT(LD_IO, "call omp_set_schedule(sched %d, modif %d)\n", (int)kind,
         modifier);
   if (isRuntimeUninitialized()) {
-    ASSERT0(LT_FUSSY, isSPMDMode(),
+    ASSERT0(LT_FUSSY, __kmpc_is_spmd_exec_mode(),
             "Expected SPMD mode only with uninitialized runtime.");
     return;
   }
   if (kind >= omp_sched_static && kind < omp_sched_auto) {
     omptarget_nvptx_TaskDescr *currTaskDescr =
-        getMyTopTaskDescriptor(isSPMDMode());
+        getMyTopTaskDescriptor(__kmpc_is_spmd_exec_mode());
     currTaskDescr->SetRuntimeSched(kind);
     currTaskDescr->RuntimeChunkSize() = modifier;
     PRINT(LD_IOD, "omp_set_schedule did set sched %d & modif %" PRIu64 "\n",
           (int)currTaskDescr->GetRuntimeSched(),
           currTaskDescr->RuntimeChunkSize());
   }
 }
 

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

INLINE static int dispatch_next(kmp_Ident *loc, int32_t gtid, int32_t *plast,
     *plast = (int32_t)(finished == LAST_CHUNK);
     *plower = myLb;
     *pupper = myUb;
     *pstride = 1;
 
     PRINT(LD_LOOP,
           "Got sched: active %d, total %d: lb %lld, ub %lld, stride = %lld, "
           "last %d\n",
-          (int)GetNumberOfOmpThreads(isSPMDMode()),
+          (int)GetNumberOfOmpThreads(__kmpc_is_spmd_exec_mode()),
           (int)GetNumberOfWorkersInTeam(), (long long)*plower,
           (long long)*pupper, (long long)*pstride, (int)*plast);
     return DISPATCH_NOTFINISHED;
   }
 
   INLINE static void dispatch_fini() {
     // nothing
   }

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

omptarget_nvptx_threadPrivateContext->SetTopLevelTaskDescr(
       threadId, currTeamDescr.LevelZeroTaskDescr());
 
   // set number of threads and thread limit in team to started value
   omptarget_nvptx_TaskDescr *currTaskDescr =
       omptarget_nvptx_threadPrivateContext->GetTopLevelTaskDescr(threadId);
   nThreads = GetNumberOfThreadsInBlock();
   threadLimit = ThreadLimit;
 
-  if (!isSPMDMode())
+  if (!__kmpc_is_spmd_exec_mode())
     omptarget_nvptx_globalArgs.Init();
 
   __kmpc_data_sharing_init_stack();
   __kmpc_impl_target_init();
 }
 
 EXTERN void __kmpc_kernel_deinit(int16_t IsOMPRuntimeInitialized) {
   PRINT0(LD_IO, "call to __kmpc_kernel_deinit\n");
if (threadId == 0) {
     // Enqueue omp state object for use by another team.
     int slot = usedSlotIdx;
     omptarget_nvptx_device_State[slot].Enqueue(
         omptarget_nvptx_threadPrivateContext);
   }
 }
 
 // Return true if the current target region is executed in SPMD mode.
 EXTERN int8_t __kmpc_is_spmd_exec_mode() {
-  PRINT0(LD_IO | LD_PAR, "call to __kmpc_is_spmd_exec_mode\n");
-  return isSPMDMode();
+  return (execution_param & ModeMask) == Spmd;
 }
 
 #pragma omp end declare target

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

 
 void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode) {
   execution_param = EMode;
   execution_param |= RMode;
 }
 
 bool isGenericMode() { return (execution_param & ModeMask) == Generic; }
 
-bool isSPMDMode() { return (execution_param & ModeMask) == Spmd; }
-
 bool isRuntimeUninitialized() {
   return (execution_param & RuntimeMask) == RuntimeUninitialized;
 }
 
 bool isRuntimeInitialized() {
   return (execution_param & RuntimeMask) == RuntimeInitialized;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Modes based on location parameter fields
 ////////////////////////////////////////////////////////////////////////////////
 
 bool checkSPMDMode(kmp_Ident *loc) {
   if (!loc)
-    return isSPMDMode();
+    return __kmpc_is_spmd_exec_mode();
 
   // If SPMD is true then we are not in the UNDEFINED state so
   // we can return immediately.
   if (loc->reserved_2 & KMP_IDENT_SPMD_MODE)
     return true;
 
   // If not in SPMD mode and runtime required is a valid
   // combination of flags so we can return immediately.
   if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE))
     return false;
 
   // We are in underfined state.
-  return isSPMDMode();
+  return __kmpc_is_spmd_exec_mode();
 }
 
 bool checkGenericMode(kmp_Ident *loc) { return !checkSPMDMode(loc); }
 
 bool checkRuntimeUninitialized(kmp_Ident *loc) {
   if (!loc)
     return isRuntimeUninitialized();
 

openmp/libomptarget/deviceRTLs/common/support.h

 enum RuntimeMode {
   RuntimeInitialized = 0x00u,
   RuntimeUninitialized = 0x02u,
   RuntimeMask = 0x02u,
 };
 
 void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode);
 bool isGenericMode();
-bool isSPMDMode();
 bool isRuntimeUninitialized();
 bool isRuntimeInitialized();
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Modes based on location parameter fields
 ////////////////////////////////////////////////////////////////////////////////
 
 bool checkSPMDMode(kmp_Ident *loc);