//===- OMPConstants.h - OpenMP related constants and 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
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This file defines constans and helpers used when dealing with OpenMP.
///
//===----------------------------------------------------------------------===//
#ifndef LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
#define LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Frontend/OpenMP/OMP.h.inc"
namespace llvm {
namespace omp {
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
/// IDs for all Internal Control Variables (ICVs).
enum class InternalControlVar {
#define ICV_DATA_ENV(Enum, ...) Enum,
#include "llvm/Frontend/OpenMP/OMPKinds.def"
};
#define ICV_DATA_ENV(Enum, ...) \
constexpr auto Enum = omp::InternalControlVar::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
enum class ICVInitValue {
#define ICV_INIT_VALUE(Enum, Name) Enum,
#include "llvm/Frontend/OpenMP/OMPKinds.def"
};
#define ICV_INIT_VALUE(Enum, Name) \
constexpr auto Enum = omp::ICVInitValue::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
/// IDs for all omp runtime library (RTL) functions.
enum class RuntimeFunction {
#define OMP_RTL(Enum, ...) Enum,
#include "llvm/Frontend/OpenMP/OMPKinds.def"
};
#define OMP_RTL(Enum, ...) constexpr auto Enum = omp::RuntimeFunction::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
/// IDs for the different default kinds.
enum class DefaultKind {
#define OMP_DEFAULT_KIND(Enum, Str) Enum,
#include "llvm/Frontend/OpenMP/OMPKinds.def"
};
#define OMP_DEFAULT_KIND(Enum, ...) \
constexpr auto Enum = omp::DefaultKind::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
/// IDs for all omp runtime library ident_t flag encodings (see
/// their defintion in openmp/runtime/src/kmp.h).
enum class IdentFlag {
#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
#include "llvm/Frontend/OpenMP/OMPKinds.def"
LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
};
#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
/// \note This needs to be kept in sync with kmp.h enum sched_type.
/// Todo: Update kmp.h to include this file, and remove the enums in kmp.h
enum class OMPScheduleType {
// For typed comparisons, not a valid schedule
None = 0,
// Schedule algorithms
BaseStaticChunked = 1,
BaseStatic = 2,
BaseDynamicChunked = 3,
BaseGuidedChunked = 4,
BaseRuntime = 5,
BaseAuto = 6,
BaseTrapezoidal = 7,
BaseGreedy = 8,
BaseBalanced = 9,
BaseGuidedIterativeChunked = 10,
BaseGuidedAnalyticalChunked = 11,
BaseSteal = 12,
// with chunk adjustment (e.g., simd)
BaseStaticBalancedChunked = 13,
BaseGuidedSimd = 14,
BaseRuntimeSimd = 15,
// static schedules algorithims for distribute
BaseDistributeChunked = 27,
BaseDistribute = 28,
// Modifier flags to be combined with schedule algorithms
ModifierUnordered = (1 << 5),
ModifierOrdered = (1 << 6),
ModifierNomerge = (1 << 7),
ModifierMonotonic = (1 << 29),
ModifierNonmonotonic = (1 << 30),
// Masks combining multiple flags
OrderingMask = ModifierUnordered | ModifierOrdered | ModifierNomerge,
MonotonicityMask = ModifierMonotonic | ModifierNonmonotonic,
ModifierMask = OrderingMask | MonotonicityMask,
// valid schedule type values, without monotonicity flags
UnorderedStaticChunked = BaseStaticChunked | ModifierUnordered, // 33
UnorderedStatic = BaseStatic | ModifierUnordered, // 34
UnorderedDynamicChunked = BaseDynamicChunked | ModifierUnordered, // 35
UnorderedGuidedChunked = BaseGuidedChunked | ModifierUnordered, // 36
UnorderedRuntime = BaseRuntime | ModifierUnordered, // 37
UnorderedAuto = BaseAuto | ModifierUnordered, // 38
UnorderedTrapezoidal = BaseTrapezoidal | ModifierUnordered, // 39
UnorderedGreedy = BaseGreedy | ModifierUnordered, // 40
UnorderedBalanced = BaseBalanced | ModifierUnordered, // 41
UnorderedGuidedIterativeChunked =
BaseGuidedIterativeChunked | ModifierUnordered, // 42
UnorderedGuidedAnalyticalChunked =
BaseGuidedAnalyticalChunked | ModifierUnordered, // 43
UnorderedSteal = BaseSteal | ModifierUnordered, // 44
UnorderedStaticBalancedChunked =
BaseStaticBalancedChunked | ModifierUnordered, // 45
UnorderedGuidedSimd = BaseGuidedSimd | ModifierUnordered, // 46
UnorderedRuntimeSimd = BaseRuntimeSimd | ModifierUnordered, // 47
OrderedStaticChunked = BaseStaticChunked | ModifierOrdered, // 65
OrderedStatic = BaseStatic | ModifierOrdered, // 66
OrderedDynamicChunked = BaseDynamicChunked | ModifierOrdered, // 67
OrderedGuidedChunked = BaseGuidedChunked | ModifierOrdered, // 68
OrderedRuntime = BaseRuntime | ModifierOrdered, // 69
OrderedAuto = BaseAuto | ModifierOrdered, // 70
OrderdTrapezoidal = BaseTrapezoidal | ModifierOrdered, // 71
OrderedDistributeChunked = BaseDistributeChunked | ModifierOrdered, // 91
OrderedDistribute = BaseDistribute | ModifierOrdered, // 92
NomergeUnorderedStaticChunked =
BaseStaticChunked | ModifierUnordered | ModifierNomerge, // 161
NomergeUnorderedStatic =
BaseStatic | ModifierUnordered | ModifierNomerge, // 162
NomergeUnorderedDynamicChunked =
BaseDynamicChunked | ModifierUnordered | ModifierNomerge, // 163
NomergeUnorderedGuidedChunked =
BaseGuidedChunked | ModifierUnordered | ModifierNomerge, // 164
NomergeUnorderedRuntime =
BaseRuntime | ModifierUnordered | ModifierNomerge, // 165
NomergeUnorderedAuto = BaseAuto | ModifierUnordered | ModifierNomerge, // 166
NomergeUnorderedTrapezoidal =
BaseTrapezoidal | ModifierUnordered | ModifierNomerge, // 167
NomergeUnorderedGreedy =
BaseGreedy | ModifierUnordered | ModifierNomerge, // 168
NomergeUnorderedBalanced =
BaseBalanced | ModifierUnordered | ModifierNomerge, // 169
NomergeUnorderedGuidedIterativeChunked =
BaseGuidedIterativeChunked | ModifierUnordered | ModifierNomerge, // 170
NomergeUnorderedGuidedAnalyticalChunked =
BaseGuidedAnalyticalChunked | ModifierUnordered | ModifierNomerge, // 171
NomergeUnorderedSteal =
BaseSteal | ModifierUnordered | ModifierNomerge, // 172
NomergeOrderedStaticChunked =
BaseStaticChunked | ModifierOrdered | ModifierNomerge, // 193
NomergeOrderedStatic = BaseStatic | ModifierOrdered | ModifierNomerge, // 194
NomergeOrderedDynamicChunked =
BaseDynamicChunked | ModifierOrdered | ModifierNomerge, // 195
NomergeOrderedGuidedChunked =
BaseGuidedChunked | ModifierOrdered | ModifierNomerge, // 196
NomergeOrderedRuntime =
BaseRuntime | ModifierOrdered | ModifierNomerge, // 197
NomergeOrderedAuto = BaseAuto | ModifierOrdered | ModifierNomerge, // 198
NomergeOrderedTrapezoidal =
BaseTrapezoidal | ModifierOrdered | ModifierNomerge, // 199
LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue */ ModifierMask)
};
/// Values for bit flags used to specify the mapping type for
/// offloading.
enum class OpenMPOffloadMappingFlags : uint64_t {
/// No flags
OMP_MAP_NONE = 0x0,
/// Allocate memory on the device and move data from host to device.
OMP_MAP_TO = 0x01,
/// Allocate memory on the device and move data from device to host.
OMP_MAP_FROM = 0x02,
/// Always perform the requested mapping action on the element, even
/// if it was already mapped before.
OMP_MAP_ALWAYS = 0x04,
/// Delete the element from the device environment, ignoring the
/// current reference count associated with the element.
OMP_MAP_DELETE = 0x08,
/// The element being mapped is a pointer-pointee pair; both the
/// pointer and the pointee should be mapped.
OMP_MAP_PTR_AND_OBJ = 0x10,
/// This flags signals that the base address of an entry should be
/// passed to the target kernel as an argument.
OMP_MAP_TARGET_PARAM = 0x20,
/// Signal that the runtime library has to return the device pointer
/// in the current position for the data being mapped. Used when we have the
/// use_device_ptr or use_device_addr clause.
OMP_MAP_RETURN_PARAM = 0x40,
/// This flag signals that the reference being passed is a pointer to
/// private data.
OMP_MAP_PRIVATE = 0x80,
/// Pass the element to the device by value.
OMP_MAP_LITERAL = 0x100,
/// Implicit map
OMP_MAP_IMPLICIT = 0x200,
/// Close is a hint to the runtime to allocate memory close to
/// the target device.
OMP_MAP_CLOSE = 0x400,
/// 0x800 is reserved for compatibility with XLC.
/// Produce a runtime error if the data is not already allocated.
OMP_MAP_PRESENT = 0x1000,
// Increment and decrement a separate reference counter so that the data
// cannot be unmapped within the associated region. Thus, this flag is
// intended to be used on 'target' and 'target data' directives because they
// are inherently structured. It is not intended to be used on 'target
// enter data' and 'target exit data' directives because they are inherently
// dynamic.
// This is an OpenMP extension for the sake of OpenACC support.
OMP_MAP_OMPX_HOLD = 0x2000,
/// Signal that the runtime library should use args as an array of
/// descriptor_dim pointers and use args_size as dims. Used when we have
/// non-contiguous list items in target update directive
OMP_MAP_NON_CONTIG = 0x100000000000,
/// The 16 MSBs of the flags indicate whether the entry is member of some
/// struct/class.
OMP_MAP_MEMBER_OF = 0xffff000000000000,
LLVM_MARK_AS_BITMASK_ENUM(/* LargestFlag = */ OMP_MAP_MEMBER_OF)
};
enum class AddressSpace : unsigned {
Generic = 0,
Global = 1,
Shared = 3,
Constant = 4,
Local = 5,
};
/// \note This needs to be kept in sync with interop.h enum kmp_interop_type_t.:
enum class OMPInteropType { Unknown, Target, TargetSync };
/// Atomic compare operations. Currently OpenMP only supports ==, >, and <.
enum class OMPAtomicCompareOp : unsigned { EQ, MIN, MAX };
/// Fields ids in kmp_depend_info record.
enum class RTLDependInfoFields { BaseAddr, Len, Flags };
/// Dependence kind for RTL.
enum class RTLDependenceKindTy {
DepUnknown = 0x0,
DepIn = 0x01,
DepInOut = 0x3,
DepMutexInOutSet = 0x4,
DepInOutSet = 0x8,
DepOmpAllMem = 0x80,
};
} // end namespace omp
} // end namespace llvm
#include "OMPDeviceConstants.h"
#endif // LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H