[Libomptarget] Allow the device runtime to be compiled for the host

[jhuber6]

Summary

Currently the OpenMP offloading device runtime is only expected to be
compiled for the specific architecture it's targeting. This is
problematic if we want to make compiling the device runtime more general
via the standar clang driver rather than invoking the clang front-end
directly. This patch addresses this by primarily changing the declare
type to nohost so the host will not contain any of this code.
Additionally we forward declare the functions that are defined via
variants, otherwise these would cause problems on the host.

[tianshilei1992]

LGTM. Just would be better to add comments for those forward declaration.

openmp/libomptarget/DeviceRTL/src/Mapping.cpp

26–43

Could you add some comments here saying that's just a declaration and every target has to implement them.

openmp/libomptarget/DeviceRTL/src/Synchronization.cpp

66

similar here

[jhuber6]

openmp/libomptarget/DeviceRTL/src/Synchronization.cpp

66

Will do.

[jdoerfert]

I'm not super happy about the forward decls. Should we augment begin declare tatrget with begin declare variant match(device={kind(nohost)}) instead?

[jhuber6]

In D125260#3503598, @jdoerfert wrote:

I'm not super happy about the forward decls. Should we augment begin declare tatrget with begin declare variant match(device={kind(nohost)}) instead?

Do you mean by changing the declare? Or by nesting variants. I wasn't sure if that worked.

[jdoerfert]

I think we are lacking a good way to do what I want, let's go ahead with forward declares for now.

openmp/libomptarget/DeviceRTL/include/Mapping.h

 #define OMPTARGET_MAPPING_H
 
 #include "Types.h"
 
 namespace _OMP {
 
 namespace mapping {
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 inline constexpr uint32_t MaxThreadsPerTeam = 1024;
 
 #pragma omp end declare target
 
 /// Initialize the mapping machinery.
 void init(bool IsSPMD);
 

openmp/libomptarget/DeviceRTL/include/State.h

 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_STATE_H
 #define OMPTARGET_STATE_H
 
 #include "Debug.h"
 #include "Types.h"
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 namespace _OMP {
 
 namespace state {
 
 inline constexpr uint32_t SharedScratchpadSize = SHARED_SCRATCHPAD_SIZE;
 
 /// Initialize the state machinery. Must be called by all threads.

openmp/libomptarget/DeviceRTL/src/Configuration.cpp

 
 #include "Configuration.h"
 #include "DeviceEnvironment.h"
 #include "State.h"
 #include "Types.h"
 
 using namespace _OMP;
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 // defined by CGOpenMPRuntimeGPU
 extern uint32_t __omp_rtl_debug_kind;
 extern uint32_t __omp_rtl_assume_no_thread_state;
 
 // TODO: We want to change the name as soon as the old runtime is gone.
 // This variable should be visibile to the plugin so we override the default
 // hidden visibility.

openmp/libomptarget/DeviceRTL/src/Debug.cpp

 #include "Debug.h"
 #include "Configuration.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "Types.h"
 
 using namespace _OMP;
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 extern "C" {
 void __assert_assume(bool condition) { __builtin_assume(condition); }
 
 void __assert_fail(const char *assertion, const char *file, unsigned line,
                    const char *function) {
   PRINTF("%s:%u: %s: Assertion `%s' failed.\n", file, line, function,
          assertion);
   __builtin_trap();
 }
 
+namespace impl {
+int32_t omp_vprintf(const char *Format, void *Arguments, uint32_t);
+}
+
 #pragma omp begin declare variant match(                                       \
     device = {arch(nvptx, nvptx64)}, implementation = {extension(match_any)})
 int32_t vprintf(const char *, void *);
 namespace impl {
 static int32_t omp_vprintf(const char *Format, void *Arguments, uint32_t) {
   return vprintf(Format, Arguments);
 }
 } // namespace impl

 #pragma omp end declare variant
 
 int32_t __llvm_omp_vprintf(const char *Format, void *Arguments, uint32_t Size) {
   return impl::omp_vprintf(Format, Arguments, Size);
 }
 }
 
 /// Current indentation level for the function trace. Only accessed by thread 0.
-__attribute__((loader_uninitialized))
-static uint32_t Level;
+__attribute__((loader_uninitialized)) static uint32_t Level;
 #pragma omp allocate(Level) allocator(omp_pteam_mem_alloc)
 
 DebugEntryRAII::DebugEntryRAII(const char *File, const unsigned Line,
                                const char *Function) {
   if (config::isDebugMode(config::DebugKind::FunctionTracing) &&
       mapping::getThreadIdInBlock() == 0 && mapping::getBlockId() == 0) {
 
     for (int I = 0; I < Level; ++I)

openmp/libomptarget/DeviceRTL/src/Kernel.cpp

 #include "Interface.h"
 #include "Mapping.h"
 #include "State.h"
 #include "Synchronization.h"
 #include "Types.h"
 
 using namespace _OMP;
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 static void inititializeRuntime(bool IsSPMD) {
   // Order is important here.
   synchronize::init(IsSPMD);
   mapping::init(IsSPMD);
   state::init(IsSPMD);
 }
 

openmp/libomptarget/DeviceRTL/src/Mapping.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Mapping.h"
 #include "Interface.h"
 #include "State.h"
 #include "Types.h"
 #include "Utils.h"
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 
 using namespace _OMP;
 
 namespace _OMP {
 namespace impl {
 
+// Forward declarations defined to be defined for AMDGCN and NVPTX.
+const llvm::omp::GV &getGridValue();
+uint32_t getGridDim(uint32_t n, uint16_t d);
+uint32_t getWorkgroupDim(uint32_t group_id, uint32_t grid_size,
+                         uint16_t group_size);
+uint32_t getNumHardwareThreadsInBlock();
+LaneMaskTy activemask();
+LaneMaskTy lanemaskLT();
+LaneMaskTy lanemaskGT();
+uint32_t getThreadIdInWarp();
+uint32_t getThreadIdInBlock();
+uint32_t getKernelSize();
+uint32_t getBlockId();
+uint32_t getNumberOfBlocks();
+uint32_t getWarpId();
+uint32_t getNumberOfWarpsInBlock();
+
 /// AMDGCN Implementation
 ///
 ///{
 #pragma omp begin declare variant match(device = {arch(amdgcn)})
 
 static const llvm::omp::GV &getGridValue() {
   return llvm::omp::getAMDGPUGridValues<__AMDGCN_WAVEFRONT_SIZE>();
 }

openmp/libomptarget/DeviceRTL/src/Misc.cpp

 //===--------- Misc.cpp - OpenMP device misc interfaces ----------- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //
 //===----------------------------------------------------------------------===//
 
 #include "Types.h"
 
 #include "Debug.h"
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 namespace _OMP {
 namespace impl {
 
+double getWTick();
+
+double getWTime();
+
 /// AMDGCN Implementation
 ///
 ///{
 #pragma omp begin declare variant match(device = {arch(amdgcn)})
 
 double getWTick() { return ((double)1E-9); }
 
 double getWTime() {

openmp/libomptarget/DeviceRTL/src/Parallelism.cpp

 #include "Mapping.h"
 #include "State.h"
 #include "Synchronization.h"
 #include "Types.h"
 #include "Utils.h"
 
 using namespace _OMP;
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 namespace {
 
 uint32_t determineNumberOfThreads(int32_t NumThreadsClause) {
   uint32_t NThreadsICV =
       NumThreadsClause != -1 ? NumThreadsClause : icv::NThreads;
   uint32_t NumThreads = mapping::getBlockSize();
 

openmp/libomptarget/DeviceRTL/src/Reduction.cpp

 #include "Synchronization.h"
 #include "Types.h"
 #include "Utils.h"
 
 using namespace _OMP;
 
 namespace {
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 void gpu_regular_warp_reduce(void *reduce_data, ShuffleReductFnTy shflFct) {
   for (uint32_t mask = mapping::getWarpSize() / 2; mask > 0; mask /= 2) {
     shflFct(reduce_data, /*LaneId - not used= */ 0,
             /*Offset = */ mask, /*AlgoVersion=*/0);
   }
 }
 

openmp/libomptarget/DeviceRTL/src/State.cpp

 #include "Interface.h"
 #include "Mapping.h"
 #include "Synchronization.h"
 #include "Types.h"
 #include "Utils.h"
 
 using namespace _OMP;
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 /// Memory implementation
 ///
 ///{
 
 /// Add worst-case padding so that future allocations are properly aligned.
 /// FIXME: The stack shouldn't require worst-case padding. Alignment needs to be
 /// passed in as an argument and the stack rewritten to support it.

openmp/libomptarget/DeviceRTL/src/Synchronization.cpp

 
 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "State.h"
 #include "Types.h"
 #include "Utils.h"
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 using namespace _OMP;
 
 namespace impl {
 
 /// Atomics
 ///
 ///{
uint32_t atomicCAS(uint32_t *Address, uint32_t Compare, uint32_t Val,
   return Compare;
 }
 
 uint64_t atomicAdd(uint64_t *Address, uint64_t Val, int Ordering) {
   return __atomic_fetch_add(Address, Val, Ordering);
 }
 ///}
 
+// Forward declarations defined to be defined for AMDGCN and NVPTX.
+uint32_t atomicInc(uint32_t *A, uint32_t V, int Ordering);
+void namedBarrierInit();
+void namedBarrier();
+void fenceTeam(int Ordering);
+void fenceKernel(int Ordering);
+void fenceSystem(int Ordering);
+void syncWarp(__kmpc_impl_lanemask_t);
+void syncThreads();
+void syncThreadsAligned() { syncThreads(); }
+void unsetLock(omp_lock_t *);
+int testLock(omp_lock_t *);
+void initLock(omp_lock_t *);
+void destroyLock(omp_lock_t *);
+void setLock(omp_lock_t *);
+
 /// AMDGCN Implementation
 ///
 ///{
 #pragma omp begin declare variant match(device = {arch(amdgcn)})
 
 uint32_t atomicInc(uint32_t *A, uint32_t V, int Ordering) {
   // builtin_amdgcn_atomic_inc32 should expand to this switch when
   // passed a runtime value, but does not do so yet. Workaround here.

openmp/libomptarget/DeviceRTL/src/Tasking.cpp

 
 #include "Interface.h"
 #include "State.h"
 #include "Types.h"
 #include "Utils.h"
 
 using namespace _OMP;
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 TaskDescriptorTy *__kmpc_omp_task_alloc(IdentTy *, uint32_t, int32_t,
                                         uint64_t TaskSizeInclPrivateValues,
                                         uint64_t SharedValuesSize,
                                         TaskFnTy TaskFn) {
   FunctionTracingRAII();
   auto TaskSizeInclPrivateValuesPadded =
       utils::roundUp(TaskSizeInclPrivateValues, uint64_t(sizeof(void *)));

openmp/libomptarget/DeviceRTL/src/Utils.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Utils.h"
 
 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 using namespace _OMP;
 
 namespace _OMP {
 /// Helper to keep code alive without introducing a performance penalty.
 __attribute__((used, retain, weak, optnone, cold)) void keepAlive() {
   __kmpc_get_hardware_thread_id_in_block();
   __kmpc_get_hardware_num_threads_in_block();
   __kmpc_get_warp_size();
   __kmpc_barrier_simple_spmd(nullptr, 0);
   __kmpc_barrier_simple_generic(nullptr, 0);
 }
 } // namespace _OMP
 
 namespace impl {
 
+void Unpack(uint64_t Val, uint32_t *LowBits, uint32_t *HighBits);
+uint64_t Pack(uint32_t LowBits, uint32_t HighBits);
+
 /// AMDGCN Implementation
 ///
 ///{
 #pragma omp begin declare variant match(device = {arch(amdgcn)})
 
 void Unpack(uint64_t Val, uint32_t *LowBits, uint32_t *HighBits) {
   static_assert(sizeof(unsigned long) == 8, "");
   *LowBits = (uint32_t)(Val & 0x00000000FFFFFFFFUL);

 uint64_t Pack(uint32_t LowBits, uint32_t HighBits) {
   uint64_t Val;
   asm("mov.b64 %0, {%1,%2};" : "=l"(Val) : "r"(LowBits), "r"(HighBits));
   return Val;
 }
 
 #pragma omp end declare variant
 
+int32_t shuffle(uint64_t Mask, int32_t Var, int32_t SrcLane);
+int32_t shuffleDown(uint64_t Mask, int32_t Var, uint32_t LaneDelta,
+                    int32_t Width);
+
 /// AMDGCN Implementation
 ///
 ///{
 #pragma omp begin declare variant match(device = {arch(amdgcn)})
 
 int32_t shuffle(uint64_t Mask, int32_t Var, int32_t SrcLane) {
   int Width = mapping::getWarpSize();
   int Self = mapping::getThreadIdInWarp();

openmp/libomptarget/DeviceRTL/src/Workshare.cpp

 #define DISPATCH_FINISHED 0
 #define DISPATCH_NOTFINISHED 1
 
 // used by dynamic scheduling
 #define FINISHED 0
 #define NOT_FINISHED 1
 #define LAST_CHUNK 2
 
-#pragma omp declare target
+#pragma omp begin declare target device_type(nohost)
 
 // TODO: This variable is a hack inherited from the old runtime.
 static uint64_t SHARED(Cnt);
 
 template <typename T, typename ST> struct omptarget_nvptx_LoopSupport {
   ////////////////////////////////////////////////////////////////////////////////
   // Loop with static scheduling with chunk