1 //===--- DeviceUtils.h - OpenMP device runtime utility functions -- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // 10 //===----------------------------------------------------------------------===// 11 12 #ifndef OMPTARGET_DEVICERTL_DEVICE_UTILS_H 13 #define OMPTARGET_DEVICERTL_DEVICE_UTILS_H 14 15 #include "DeviceTypes.h" 16 #include "Shared/Utils.h" 17 18 #pragma omp begin declare target device_type(nohost) 19 20 namespace utils { 21 22 template <typename T> struct type_identity { 23 using type = T; 24 }; 25 26 template <typename T, T v> struct integral_constant { 27 inline static constexpr T value = v; 28 }; 29 30 /// Freestanding SFINAE helpers. 31 template <class T> struct remove_cv : type_identity<T> {}; 32 template <class T> struct remove_cv<const T> : type_identity<T> {}; 33 template <class T> struct remove_cv<volatile T> : type_identity<T> {}; 34 template <class T> struct remove_cv<const volatile T> : type_identity<T> {}; 35 template <class T> using remove_cv_t = typename remove_cv<T>::type; 36 37 using true_type = integral_constant<bool, true>; 38 using false_type = integral_constant<bool, false>; 39 40 template <typename T, typename U> struct is_same : false_type {}; 41 template <typename T> struct is_same<T, T> : true_type {}; 42 template <typename T, typename U> 43 inline constexpr bool is_same_v = is_same<T, U>::value; 44 45 template <typename T> struct is_floating_point { 46 inline static constexpr bool value = 47 is_same_v<remove_cv_t<T>, float> || is_same_v<remove_cv_t<T>, double>; 48 }; 49 template <typename T> 50 inline constexpr bool is_floating_point_v = is_floating_point<T>::value; 51 52 template <bool B, typename T = void> struct enable_if; 53 template <typename T> struct enable_if<true, T> : type_identity<T> {}; 54 template <bool B, typename T = void> 55 using enable_if_t = typename enable_if<B, T>::type; 56 57 template <class T> struct remove_addrspace : type_identity<T> {}; 58 template <class T, int N> 59 struct remove_addrspace<T [[clang::address_space(N)]]> : type_identity<T> {}; 60 template <class T> 61 using remove_addrspace_t = typename remove_addrspace<T>::type; 62 63 template <typename To, typename From> inline To bitCast(From V) { 64 static_assert(sizeof(To) == sizeof(From), "Bad conversion"); 65 return __builtin_bit_cast(To, V); 66 } 67 68 /// Return the value \p Var from thread Id \p SrcLane in the warp if the thread 69 /// is identified by \p Mask. 70 int32_t shuffle(uint64_t Mask, int32_t Var, int32_t SrcLane, int32_t Width); 71 72 int32_t shuffleDown(uint64_t Mask, int32_t Var, uint32_t Delta, int32_t Width); 73 74 int64_t shuffleDown(uint64_t Mask, int64_t Var, uint32_t Delta, int32_t Width); 75 76 uint64_t ballotSync(uint64_t Mask, int32_t Pred); 77 78 /// Return \p LowBits and \p HighBits packed into a single 64 bit value. 79 uint64_t pack(uint32_t LowBits, uint32_t HighBits); 80 81 /// Unpack \p Val into \p LowBits and \p HighBits. 82 void unpack(uint64_t Val, uint32_t &LowBits, uint32_t &HighBits); 83 84 /// Return true iff \p Ptr is pointing into shared (local) memory (AS(3)). 85 bool isSharedMemPtr(void *Ptr); 86 87 /// Return true iff \p Ptr is pointing into (thread) local memory (AS(5)). 88 bool isThreadLocalMemPtr(void *Ptr); 89 90 /// A pointer variable that has by design an `undef` value. Use with care. 91 [[clang::loader_uninitialized]] static void *const UndefPtr; 92 93 #define OMP_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true) 94 #define OMP_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false) 95 96 } // namespace utils 97 98 #pragma omp end declare target 99 100 #endif 101