[OpenMP] Rename the `_OMP` namespace in the device runtime to `ompx`

[jhuber6]

I'm guessing this is to export it to the user later, changes nothing functionally right now so looks fine.

[ronlieb]

Hi, amdgpu buildbot failing this test after this patch landed

libomptarget :: amdgcn-amd-amdhsa :: api/omp_dynamic_shared_memory_amdgpu.c

patch seems revertable.

openmp/libomptarget/DeviceRTL/include/Configuration.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_CONFIGURATION_H
 #define OMPTARGET_CONFIGURATION_H
 
 #include "Types.h"
 
-namespace _OMP {
+namespace ompx {
 namespace config {
 
 enum DebugKind : uint32_t {
   Assertion = 1U << 0,
   FunctionTracing = 1U << 1,
   CommonIssues = 1U << 2,
 };
 

 /// explicitly disabled by the user.
 bool mayUseThreadStates();
 
 /// Indicates if this kernel may require data environments for nested
 /// parallelism, or if it was explicitly disabled by the user.
 bool mayUseNestedParallelism();
 
 } // namespace config
-} // namespace _OMP
+} // namespace ompx
 
 #endif

openmp/libomptarget/DeviceRTL/include/Mapping.h

 //===--------- Mapping.h - OpenMP device runtime mapping helpers -- 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
 //
 //===----------------------------------------------------------------------===//
 //
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_MAPPING_H
 #define OMPTARGET_MAPPING_H
 
 #include "Types.h"
 
-namespace _OMP {
+namespace ompx {
 
 namespace mapping {
 
 #pragma omp begin declare target device_type(nohost)
 
 inline constexpr uint32_t MaxThreadsPerTeam = 1024;
 
 #pragma omp end declare target

 /// Return the kernel size, thus number of threads in the kernel.
 uint32_t getKernelSize();
 
 /// Return the number of processing elements on the device.
 uint32_t getNumberOfProcessorElements();
 
 } // namespace mapping
 
-} // namespace _OMP
+} // namespace ompx
 
 #endif

openmp/libomptarget/DeviceRTL/include/State.h

 
 #include "Debug.h"
 #include "Mapping.h"
 #include "Types.h"
 #include "Utils.h"
 
 #pragma omp begin declare target device_type(nohost)
 
-namespace _OMP {
+namespace ompx {
 
 namespace memory {
 
 /// Alloca \p Size bytes in shared memory, if possible, for \p Reason.
 ///
 /// Note: See the restrictions on __kmpc_alloc_shared for proper usage.
 void *allocShared(uint64_t Size, const char *Reason);
 

 /// TODO
 inline state::Value<uint32_t, state::VK_MaxActiveLevels> MaxActiveLevels;
 
 /// TODO
 inline state::Value<uint32_t, state::VK_RunSched> RunSched;
 
 } // namespace icv
 
-} // namespace _OMP
+} // namespace ompx
 
 #pragma omp end declare target
 
 #endif

openmp/libomptarget/DeviceRTL/include/Synchronization.h

 //===- Synchronization.h - OpenMP synchronization utilities ------- 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
 //
 //===----------------------------------------------------------------------===//
 //
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_DEVICERTL_SYNCHRONIZATION_H
 #define OMPTARGET_DEVICERTL_SYNCHRONIZATION_H
 
 #include "Types.h"
 
-namespace _OMP {
+namespace ompx {
 
 namespace synchronize {
 
 /// Initialize the synchronization machinery. Must be called by all threads.
 void init(bool IsSPMD);
 
 /// Synchronize all threads in a warp identified by \p Mask.
 void warp(LaneMaskTy Mask);

 /// Memory fence with \p Ordering semantics for the contention group.
 void kernel(atomic::OrderingTy Ordering);
 
 /// Memory fence with \p Ordering semantics for the system.
 void system(atomic::OrderingTy Ordering);
 
 } // namespace fence
 
-} // namespace _OMP
+} // namespace ompx
 
 #endif

openmp/libomptarget/DeviceRTL/include/Utils.h

 
 #ifndef OMPTARGET_DEVICERTL_UTILS_H
 #define OMPTARGET_DEVICERTL_UTILS_H
 
 #include "Types.h"
 
 #pragma omp begin declare target device_type(nohost)
 
-namespace _OMP {
+namespace ompx {
 namespace utils {
 
 /// Return the value \p Var from thread Id \p SrcLane in the warp if the thread
 /// is identified by \p Mask.
 int32_t shuffle(uint64_t Mask, int32_t Var, int32_t SrcLane);
 
 int32_t shuffleDown(uint64_t Mask, int32_t Var, uint32_t Delta, int32_t Width);
 

 
 /// A  pointer variable that has by design an `undef` value. Use with care.
 __attribute__((loader_uninitialized)) static void *const UndefPtr;
 
 #define OMP_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
 #define OMP_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
 
 } // namespace utils
-} // namespace _OMP
+} // namespace ompx
 
 #pragma omp end declare target
 
 #endif

openmp/libomptarget/DeviceRTL/src/Configuration.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "Configuration.h"
 #include "DeviceEnvironment.h"
 #include "State.h"
 #include "Types.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 #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;
 extern uint32_t __omp_rtl_assume_no_nested_parallelism;
 

openmp/libomptarget/DeviceRTL/src/Debug.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Debug.h"
 #include "Configuration.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "Types.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 #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) {

openmp/libomptarget/DeviceRTL/src/Kernel.cpp

 
 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "State.h"
 #include "Synchronization.h"
 #include "Types.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 #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 "State.h"
 #include "Types.h"
 #include "Utils.h"
 
 #pragma omp begin declare target device_type(nohost)
 
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
 
-using namespace _OMP;
+using namespace ompx;
 
-namespace _OMP {
+namespace ompx {
 namespace impl {
 
 // Forward declarations defined to be defined for AMDGCN and NVPTX.
 const llvm::omp::GV &getGridValue();
 uint32_t getNumHardwareThreadsInBlock();
 LaneMaskTy activemask();
 LaneMaskTy lanemaskLT();
 LaneMaskTy lanemaskGT();

 }
 
 #pragma omp end declare variant
 ///}
 
 uint32_t getWarpSize() { return getGridValue().GV_Warp_Size; }
 
 } // namespace impl
-} // namespace _OMP
+} // namespace ompx
 
 /// We have to be deliberate about the distinction of `mapping::` and `impl::`
 /// below to avoid repeating assumptions or including irrelevant ones.
 ///{
 
 static bool isInLastWarp() {
   uint32_t MainTId = (mapping::getNumberOfProcessorElements() - 1) &
                      ~(mapping::getWarpSize() - 1);

openmp/libomptarget/DeviceRTL/src/Misc.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Types.h"
 
 #include "Debug.h"
 
 #pragma omp begin declare target device_type(nohost)
 
-namespace _OMP {
+namespace ompx {
 namespace impl {
 
 double getWTick();
 
 double getWTime();
 
 /// AMDGCN Implementation
 ///
double getWTime() {
   unsigned long long nsecs;
   asm volatile("mov.u64  %0, %%globaltimer;" : "=l"(nsecs));
   return (double)nsecs * getWTick();
 }
 
 #pragma omp end declare variant
 
 } // namespace impl
-} // namespace _OMP
+} // namespace ompx
 
 /// Interfaces
 ///
 ///{
 
 extern "C" {
 int32_t __kmpc_cancellationpoint(IdentTy *, int32_t, int32_t) {
   FunctionTracingRAII();
   return 0;
 }
 
 int32_t __kmpc_cancel(IdentTy *, int32_t, int32_t) {
   FunctionTracingRAII();
   return 0;
 }
 
-double omp_get_wtick(void) { return _OMP::impl::getWTick(); }
+double omp_get_wtick(void) { return ompx::impl::getWTick(); }
 
-double omp_get_wtime(void) { return _OMP::impl::getWTime(); }
+double omp_get_wtime(void) { return ompx::impl::getWTime(); }
 }
 
 ///}
 #pragma omp end declare target

openmp/libomptarget/DeviceRTL/src/Parallelism.cpp

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

openmp/libomptarget/DeviceRTL/src/Reduction.cpp

 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "State.h"
 #include "Synchronization.h"
 #include "Types.h"
 #include "Utils.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 namespace {
 
 #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,

openmp/libomptarget/DeviceRTL/src/State.cpp

 #include "Configuration.h"
 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "Synchronization.h"
 #include "Types.h"
 #include "Utils.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 #pragma omp begin declare target device_type(nohost)
 
 /// Memory implementation
 ///
 ///{
 
 /// Add worst-case padding so that future allocations are properly aligned.

 }
 
 void state::TeamStateTy::assertEqual(TeamStateTy &Other) const {
   ICVState.assertEqual(Other.ICVState);
   ASSERT(ParallelTeamSize == Other.ParallelTeamSize);
   ASSERT(HasThreadState == Other.HasThreadState);
 }
 
-state::TeamStateTy SHARED(_OMP::state::TeamState);
-state::ThreadStateTy **SHARED(_OMP::state::ThreadStates);
+state::TeamStateTy SHARED(ompx::state::TeamState);
+state::ThreadStateTy **SHARED(ompx::state::ThreadStates);
 
 namespace {
 
 int returnValIfLevelIsActive(int Level, int Val, int DefaultVal,
                              int OutOfBoundsVal = -1) {
   if (Level == 0)
     return DefaultVal;
   int LevelVar = omp_get_level();

openmp/libomptarget/DeviceRTL/src/Synchronization.cpp

 #include "Interface.h"
 #include "Mapping.h"
 #include "State.h"
 #include "Types.h"
 #include "Utils.h"
 
 #pragma omp begin declare target device_type(nohost)
 
-using namespace _OMP;
+using namespace ompx;
 
 namespace impl {
 
 /// Atomics
 ///
 ///{
 /// NOTE: This function needs to be implemented by every target.
 uint32_t atomicInc(uint32_t *Address, uint32_t Val,

openmp/libomptarget/DeviceRTL/src/Tasking.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "Interface.h"
 #include "State.h"
 #include "Types.h"
 #include "Utils.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 #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();

openmp/libomptarget/DeviceRTL/src/Utils.cpp

 #include "Utils.h"
 
 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 
 #pragma omp begin declare target device_type(nohost)
 
-using namespace _OMP;
+using namespace ompx;
 
 extern "C" __attribute__((weak)) int IsSPMDMode;
 
 /// Helper to keep code alive without introducing a performance penalty.
 extern "C" __attribute__((weak, optnone, cold, used, retain)) void
 __keep_alive() {
   __kmpc_get_hardware_thread_id_in_block();
   __kmpc_get_hardware_num_threads_in_block();

openmp/libomptarget/DeviceRTL/src/Workshare.cpp

 #include "Debug.h"
 #include "Interface.h"
 #include "Mapping.h"
 #include "State.h"
 #include "Synchronization.h"
 #include "Types.h"
 #include "Utils.h"
 
-using namespace _OMP;
+using namespace ompx;
 
 // TODO:
 struct DynamicScheduleTracker {
   int64_t Chunk;
   int64_t LoopUpperBound;
   int64_t NextLowerBound;
   int64_t Stride;
   kmp_sched_t ScheduleType;