[libomptarget][nfc][devicertl] Split execution params

[JonChesterfield]

Summary

Use two uint16_t shared variables in place of one uint32_t
Intended to simplify load/store propagation, as part of working out
why some dead branches remain in spmd kernels.

Uses uint16_t as there are no existing uint8_t shared variables.

[JonChesterfield]

• typo

[JonChesterfield]

This did not fix the codegen I wanted it to - the LDS variables that only have one store of a constant, followed by loads, do not propagate that constant - but it should make such a transform easier. No known bits or looking through the bitwise op required.

We may get a reasonable hit rate for shared/lds memory out of a transform that looks at a variable that starts undef, and only ever has one constant stored to it, therefore assuming every load is of that constant (as undef loads may as well be assumed to be that constant).

openmp/libomptarget/deviceRTLs/common/omptarget.h

 //===---- omptarget.h - OpenMP GPU initialization ---------------- 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 declarations of all library macros, types,
 // and functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_H
 #define OMPTARGET_H
 
 #include "common/allocator.h"
 #include "common/debug.h" // debug
 #include "common/state-queue.h"
 #include "common/support.h"
 #include "interface.h" // interfaces with omp, compiler, and user
 #include "target_impl.h"
 
 #define OMPTARGET_NVPTX_VERSION 1.1
 

 extern uint8_t EXTERN_SHARED(parallelLevel)[MAX_THREADS_PER_TEAM / WARPSIZE];
 #endif
 extern uint16_t EXTERN_SHARED(threadLimit);
 extern uint16_t EXTERN_SHARED(threadsInTeam);
 extern uint16_t EXTERN_SHARED(nThreads);
 extern omptarget_nvptx_ThreadPrivateContext *
     EXTERN_SHARED(omptarget_nvptx_threadPrivateContext);
 
-extern uint32_t EXTERN_SHARED(execution_param);
+extern uint16_t EXTERN_SHARED(executionMode);
+extern uint16_t EXTERN_SHARED(runtimeMode);
+
 extern void *EXTERN_SHARED(ReductionScratchpadPtr);
 
 ////////////////////////////////////////////////////////////////////////////////
 // work function (outlined parallel/simd functions) and arguments.
 // needed for L1 parallelism only.
 ////////////////////////////////////////////////////////////////////////////////
 
 typedef void *omptarget_nvptx_WorkFn;

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

 // communicate with the workers.  Since it is in shared memory, there is one
 // copy of these variables for each kernel, instance, and team.
 ////////////////////////////////////////////////////////////////////////////////
 volatile omptarget_nvptx_WorkFn SHARED(omptarget_nvptx_workFn);
 
 ////////////////////////////////////////////////////////////////////////////////
 // OpenMP kernel execution parameters
 ////////////////////////////////////////////////////////////////////////////////
-uint32_t SHARED(execution_param);
+uint16_t SHARED(executionMode);
+uint16_t SHARED(runtimeMode);
 
 ////////////////////////////////////////////////////////////////////////////////
 // Scratchpad for teams reduction.
 ////////////////////////////////////////////////////////////////////////////////
 void *SHARED(ReductionScratchpadPtr);
 
 ////////////////////////////////////////////////////////////////////////////////
 // Data sharing related variables.
 ////////////////////////////////////////////////////////////////////////////////
 omptarget_nvptx_SharedArgs SHARED(omptarget_nvptx_globalArgs);
 
 #pragma omp end declare target

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

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() {
-  return (execution_param & ModeMask) == Spmd;
-}
+EXTERN int8_t __kmpc_is_spmd_exec_mode() { return executionMode == Spmd; }
 
 #pragma omp end declare target

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

 #include "common/omptarget.h"
 #include "common/support.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
 
 void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode) {
-  execution_param = EMode;
-  execution_param |= RMode;
+  executionMode = EMode;
+  runtimeMode = RMode;
 }
 
-bool isGenericMode() { return (execution_param & ModeMask) == Generic; }
+bool isRuntimeUninitialized() { return runtimeMode == RuntimeUninitialized; }
 
-bool isRuntimeUninitialized() {
-  return (execution_param & RuntimeMask) == RuntimeUninitialized;
-}
-
-bool isRuntimeInitialized() {
-  return (execution_param & RuntimeMask) == RuntimeInitialized;
-}
+bool isRuntimeInitialized() { return !isRuntimeUninitialized(); }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Modes based on location parameter fields
 ////////////////////////////////////////////////////////////////////////////////
 
 bool checkSPMDMode(kmp_Ident *loc) {
   if (!loc)
     return __kmpc_is_spmd_exec_mode();

openmp/libomptarget/deviceRTLs/common/support.h

 #include "target_impl.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
 enum ExecutionMode {
   Spmd = 0x00u,
   Generic = 0x01u,
-  ModeMask = 0x01u,
 };
 
 enum RuntimeMode {
   RuntimeInitialized = 0x00u,
   RuntimeUninitialized = 0x02u,
-  RuntimeMask = 0x02u,
 };
 
 void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode);
-bool isGenericMode();
 bool isRuntimeUninitialized();
 bool isRuntimeInitialized();
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Modes based on location parameter fields
 ////////////////////////////////////////////////////////////////////////////////
 
 bool checkSPMDMode(kmp_Ident *loc);