proteus Namespace Reference

Namespaces
namespace	builtins
namespace	detail
namespace	helpers
namespace	hipdyn
namespace	runtime

Classes
class	AnnotationHandler
struct	ArgTypeList
struct	ArrayInfo
class	BinaryInfo
struct	CacheEntry
struct	CallerFrame
class	CodeBuilder
class	CodeGenerationConfig
class	CommThreadHandle
	Manages the lifecycle of a background communication thread. More...
class	CompilationResult
class	CompilationTask
struct	CompiledLibrary
class	CompilerAsync
class	CompilerSync
class	Config
struct	CppJitArtifact
class	CppJitCompiler
struct	CppJitCompileRequest
class	CppJitModule
struct	DeviceTraits
struct	DeviceTraits< JitEngineDeviceCUDA >
struct	DeviceTraits< JitEngineDeviceHIP >
class	Dispatcher
class	DispatcherHost
struct	DispatchResult
struct	EmittedLoopTag
struct	EmptyLambda
struct	FatbinWrapperT
struct	FnSig
struct	FnSig< RetT_(ArgT...)>
class	ForLoopBuilder
class	Func
class	FuncBase
struct	FunctionAnalysis
struct	GlobalVarInfo
class	HashT
struct	InitLLVMTargets
struct	IntrinsicOperandConverter
class	IRFunction
struct	IRType
class	IRValue
struct	IsForLoopBuilder
struct	IsForLoopBuilder< ForLoopBuilder< T, BodyLambda > >
class	JitEngine
class	JitEngineDevice
class	JitEngineDeviceCUDA
class	JitEngineDeviceHIP
class	JitEngineHost
class	JitEngineInfoRegistry
struct	JitFunctionInfo
class	JITKernelInfo
class	JitModule
struct	JITPassPluginConfig
struct	JITPassPluginInsertion
class	KernelName
class	LambdaArgVisitor
class	LambdaInstUseVisitor
struct	LambdaKernelArgAnalysis
struct	LambdaKernelArgLocation
struct	LambdaPtrUseAnalysis
class	LambdaRegistry
struct	LinkingCloner
class	LLVMCodeBuilder
class	LLVMIRFunction
class	LLVMIRJitModule
class	LLVMIRValue
class	Logger
struct	LookupRequest
struct	LookupResponse
class	LoopBoundInfo
struct	LoopHints
class	LoopNestBuilder
class	MemoryCache
class	MLIRCodeBuilder
class	MLIRIRFunction
class	MLIRIRValue
class	MLIRJitModule
struct	MLIRLoweringOptions
struct	MLIRLoweringResult
struct	ModuleInfo
class	MPICommHandle
	RAII wrapper for MPI communicator with thread safety checks. More...
class	MPILocalLookupCache
class	MPIRemoteLookupCache
class	MPIStorageCache
class	ObjectCache
class	ObjectCacheChain
struct	ObjectInfo
struct	OptimizationPipelineConfig
struct	ProteusTypes
struct	ReachingPointerStores
struct	RegisterFatBinaryInfo
struct	RegisterFunctionInfo
struct	RegisterLinkedBinaryInfo
struct	RegisterVarInfo
struct	ResolvedCUDAToolchain
struct	ResolvedHIPToolchain
struct	ResolvedToolPath
struct	RuntimeConstant
struct	RuntimeConstantArgInfo
struct	RuntimeConstantArrayInfo
struct	RuntimeConstantInfo
struct	RuntimeConstantObjectInfo
union	RuntimeConstantValue
class	ScopedTimeTrace
struct	sig_traits
struct	sig_traits< R(Args...)>
class	StorageCache
struct	StoreMessage
class	Timer
class	TimeTracerRAII
struct	TimeTraceScopeWrapper
class	TimeTraceThreadRAII
class	TransformArgumentSpecialization
class	TransformLambdaSpecialization
class	TransformSharedArray
struct	TypeMap
struct	TypeMap< bool >
struct	TypeMap< bool[]>
struct	TypeMap< const T * >
struct	TypeMap< const T >
struct	TypeMap< double * >
struct	TypeMap< double >
struct	TypeMap< double[]>
struct	TypeMap< float * >
struct	TypeMap< float >
struct	TypeMap< float[]>
struct	TypeMap< int * >
struct	TypeMap< int >
struct	TypeMap< int[]>
struct	TypeMap< size_t >
struct	TypeMap< size_t[]>
struct	TypeMap< T & >
struct	TypeMap< unsigned int * >
struct	TypeMap< unsigned int >
struct	TypeMap< unsigned int[]>
struct	TypeMap< void >
struct	UseEdge
struct	Var
struct	Var< T, std::enable_if_t< is_pointer_unref_v< T > > >
struct	Var< T, std::enable_if_t< is_scalar_arithmetic_v< T > > >
struct	Var< T, std::enable_if_t< std::is_array_v< T > > >
struct	VarAlloc
struct	WorkItem

Typedefs
using	LambdaKernelArgLocationVec = SmallVector< LambdaKernelArgLocation, 4 >
using	LambdaKernelArgLocationMap = DenseMap< uint64_t, LambdaKernelArgLocationVec >
using	LambdaCallsiteLocationMap = DenseMap< uint64_t, DenseMap< uint32_t, LambdaKernelArgLocation > >
using	LambdaCallsiteRuntimeConstants = SmallVector< RuntimeConstant, 8 >
using	LambdaCallsiteRuntimeConstantsMap = DenseMap< uint64_t, LambdaCallsiteRuntimeConstants >
template<typename T >
using	remove_cvref_t = std::remove_cv_t< std::remove_reference_t< T > >

Enumerations
enum class	MPITag : int { Store = 1 , LookupRequest = 2 , LookupResponse = 3 }
enum class	CodegenOption { RTC , Serial , Parallel }
enum class	KernelCloneOption { LinkClonePrune , LinkCloneLight , CrossClone }
enum class	TraceOption : unsigned { Specialization = 0x1 , IRDump = 0x2 , KernelTrace = 0x4 , CacheStats = 0x8 }
enum class	AddressSpace : unsigned int {   DEFAULT = 0 , GLOBAL = 1 , SHARED = 3 , CONSTANT = 4 ,   LOCAL = 5 }
enum	RuntimeConstantType : int32_t {   BEGIN , NONE = 0 , BOOL = 1 , INT8 ,   INT32 , INT64 , FLOAT , DOUBLE ,   LONG_DOUBLE , PTR , STATIC_ARRAY , VECTOR ,   ARRAY , OBJECT , END }
enum class	CppJitCompilerBackend { Clang , Nvcc }
enum class	ScopeKind { FUNCTION , IF , FOR , WHILE }
enum class	ArithOp {   Add , Sub , Mul , Div ,   Rem }
	Semantic arithmetic operation selector. More...
enum class	CmpOp {   EQ , NE , LT , LE ,   GT , GE }
	Semantic comparison operation selector. More...
enum class	CodeBuilderKind { LLVM , MLIR }
enum class	EmissionPolicy { Eager , Lazy }
enum class	IRTypeKind {   Void , Int1 , Int16 , Int32 ,   Int64 , Float , Double , Pointer ,   Array }
enum class	TargetModelType {   HOST , CUDA , HIP , HOST_HIP ,   HOST_CUDA }
enum class	JITPassPluginPosition { Prepend , Append }
enum class	JitFuncAttribute { MaxDynamicSharedMemorySize }
enum class	LLVMIRInputKind { Auto , TextIR , Bitcode }

Functions
void	validateMPIConfig ()
std::vector< char >	packStoreMessage (MPI_Comm Comm, const HashT &HashValue, const CacheEntry &Entry)
StoreMessage	unpackStoreMessage (MPI_Comm Comm, const std::vector< char > &Buffer)
std::unique_ptr< Module >	cloneKernelFromModule (Module &M, StringRef Name, CallGraph &CG)
std::unique_ptr< Module >	cloneKernelFromModules (ArrayRef< std::reference_wrapper< Module > > Mods, StringRef EntryName, function_ref< bool(const GlobalValue *)> ShouldCloneDefinition=nullptr)
template<typename T >
T	getRuntimeConstantValue (void *Arg)
RuntimeConstant	dispatchGetRuntimeConstantValue (void **Args, const RuntimeConstantInfo &RCInfo)
std::string	toString (CodegenOption Option)
std::string	toString (KernelCloneOption Option)
std::optional< std::string >	getEnvOrDefaultString (const char *VarName)
char	getEnvOrDefaultChar (const char *VarName, char Default)
bool	getEnvOrDefaultBool (const char *VarName, bool Default)
int	getEnvOrDefaultInt (const char *VarName, int Default)
CodegenOption	strToCG (std::string CGstr)
CodegenOption	getEnvOrDefaultCG (const char *VarName, CodegenOption Default)
template<typename T >
T	getDefaultValueFromOptional (std::optional< T > JSONValue, T Default)
unsigned	parseTraceConfig (const char *VarName)
KernelCloneOption	getEnvOrDefaultKC (const char *VarName, KernelCloneOption Default)
llvm::StringMap< const CodeGenerationConfig >	parseJSONConfig (std::optional< std::string > JSONFn)
void *	resolveDeviceGlobalAddr (const void *Addr)
cudaError_t	launchKernelDirect (void *KernelFunc, dim3 GridDim, dim3 BlockDim, void **KernelArgs, uint64_t ShmemSize, CUstream Stream)
CUfunction	getKernelFunctionFromImage (StringRef KernelName, const void *Image, bool RelinkGlobalsByCopy, const std::unordered_map< std::string, GlobalVarInfo > &VarNameToGlobalInfo)
cudaError_t	launchKernelFunction (CUfunction KernelFunc, dim3 GridDim, dim3 BlockDim, void **KernelArgs, uint64_t ShmemSize, CUstream Stream)
hipError_t	launchKernelDirect (void *KernelFunc, dim3 GridDim, dim3 BlockDim, void **KernelArgs, uint64_t ShmemSize, hipStream_t Stream)
hipError_t	launchKernelFunction (hipFunction_t KernelFunc, dim3 GridDim, dim3 BlockDim, void **KernelArgs, uint64_t ShmemSize, hipStream_t Stream)
void	optimizeIR (Module &M, StringRef Arch, const OptimizationPipelineConfig &OptConfig)
std::unique_ptr< Module >	linkModules (LLVMContext &Ctx, SmallVector< std::unique_ptr< Module > > LinkedModules)
void	pruneDanglingNVVMAnnotations (Module &M)
void	runCleanupPassPipeline (Module &M)
void	findFunctionsWithU64Metadata (llvm::Module &M, llvm::StringRef Key, llvm::SmallVectorImpl< std::pair< llvm::Function *, std::uint64_t > > &Out)
void	findFunctionsWithU64Metadata (llvm::Module &M, llvm::StringRef Key, llvm::SmallVectorImpl< std::uint64_t > &Out)
bool	hasU64Metadata (Function *F, StringRef Key)
void	pruneIR (Module &M, bool UnsetExternallyInitialized=true)
void	internalize (Module &M, StringRef PreserveFunctionName)
std::optional< uint64_t >	getFunctionU64Metadata (Function &F, StringRef Key)
void	setLaunchBoundsForKernel (Function &F, int MaxThreadsPerSM, int MinBlocksPerSM=0)
void	codegenPTX (Module &M, StringRef DeviceArch, SmallVectorImpl< char > &PTXStr)
std::unique_ptr< MemoryBuffer >	codegenObject (Module &M, StringRef DeviceArch, SmallPtrSetImpl< void * > &GlobalLinkedBinaries, CodegenOption CGOption=CodegenOption::RTC)
std::unique_ptr< MemoryBuffer >	codegenObject (Module &M, StringRef DeviceArch, SmallPtrSetImpl< void * > &GlobalLinkedBinaries, CodegenOption CGOption=CodegenOption::RTC, const OptimizationPipelineConfig &OptConfig=OptimizationPipelineConfig(std::nullopt, '3', 3))
std::string	toString (Value &V)
HashT	computeCppJitModuleHash (TargetModelType TM, CppJitCompilerBackend Backend, const std::string &Code, const std::vector< std::string > &ExtraArgs)
const ResolvedToolPath &	resolveClangxx ()
std::unique_ptr< CppJitCompiler >	createCppJitCompiler (const CppJitCompileRequest &Request)
std::unique_ptr< CppJitCompiler >	createCppJitCompilerClang ()
const ResolvedCUDAToolchain &	resolveCUDAToolchain ()
const ResolvedHIPToolchain &	resolveHIPToolchain ()
void	setFuncAttribute (TargetModelType TargetModel, void *KernelFunc, JitFuncAttribute Attr, int Value)
void	registerMLIRLoweringDialects (mlir::DialectRegistry &Registry)
void	loadMLIRLoweringDialects (mlir::MLIRContext &Context)
MLIRLoweringResult	lowerMLIRModuleToLLVM (mlir::ModuleOp Module, const MLIRLoweringOptions &Options)
HashT	hashValue (const HashT &H)
HashT	hashValue (const StringRef &S)
HashT	hashValue (const std::string &S)
template<typename T >
std::enable_if_t< std::is_scalar< T >::value, HashT >	hashValue (const T &V)
template<typename T >
HashT	hashRuntimeConstantArray (const RuntimeConstant &RC)
HashT	hashRuntimeConstantObject (const RuntimeConstant &RC)
HashT	hashArrayRefElement (const RuntimeConstant &RC)
HashT	hashValue (const RuntimeConstant &RC)
HashT	hashValue (ArrayRef< RuntimeConstant > Arr)
template<typename T >
HashT	hashValue (ArrayRef< T > Arr)
template<typename T , unsigned N>
HashT	hashValue (const SmallVector< T, N > &Vec)
template<typename Key , typename Value >
std::enable_if_t< std::is_integral< Key >::value||std::is_enum< Key >::value, HashT >	hashValue (const DenseMap< Key, Value > &Map)
template<typename Key , typename Value >
HashT	hashValue (DenseMap< Key, Value > &Map)
HashT	hashCombine (HashT A, HashT B)
HashT	hashCodeGenConfig (const CodeGenerationConfig &CGConfig)
HashT	hashRuntimeSpecializationConfig (const CodeGenerationConfig &CGConfig)
HashT	hashValue (const CodeGenerationConfig &CGConfig)
template<typename FirstT , typename... RestTs>
HashT	hash (FirstT &&First, RestTs &&...Rest)
template<typename T >
HashT	hash (T &&Data)
void	registerJITPassPluginImpl (const std::string &PluginPath, std::optional< JITPassPluginInsertion > Insertion)
void	clearJITPassPluginsImpl ()
std::vector< JITPassPluginConfig >	getJITPassPluginConfigs ()
void	setLambdaCallsiteMetadata (CallBase &CB, uint64_t LambdaID, uint32_t CallsiteIndex)
std::optional< std::pair< uint64_t, uint32_t > >	getLambdaCallsiteMetadata (const CallBase &CB)
std::optional< uint32_t >	getLambdaCallsiteIndex (const CallBase &CB, uint64_t ExpectedLambdaID)
LambdaKernelArgLocationVec	getOrderedLambdaKernelArgLocations (const DenseMap< uint32_t, LambdaKernelArgLocation > &CallsiteLocations)
RuntimeConstantType	convertTypeToRuntimeConstantType (Type *Ty)
Type *	convertRuntimeConstantTypeToLLVMType (RuntimeConstantType RCType, LLVMContext &Ctx)
std::string	toString (const RuntimeConstantType RCType)
size_t	getSizeInBytes (RuntimeConstantType RCType)
template<typename T >
T	getValue (const RuntimeConstant &RC)
bool	isScalarRuntimeConstantType (RuntimeConstantType RCType)
Constant *	getConstant (LLVMContext &Ctx, Type *ArgType, const RuntimeConstant &RC)
bool	isDebugOutputEnabled ()
bool	isDeviceCompilation (Module &M)
std::string	getUniqueFileID (Module &M)
std::string	getCanonicalSourceFileName (Module &M)
bool	isDeviceKernel (const Function *F)
bool	needsDefUseAnalysis (Value *Val)
bool	offsetCoveredByRange (int64_t TargetOffset, int64_t RangeOffset, uint64_t RangeSize)
std::optional< uint64_t >	getTypeStoreSize (const DataLayout &DL, Type *Ty)
std::optional< MemoryLocation >	getTrackedPointerLocation (const DataLayout &DL, Value *Ptr)
std::optional< LambdaPtrUseAnalysis >	getPreviousCoveringStore (const DataLayout &DL, Value *Ptr, Value *UseBoundary, int64_t TargetOffset)
std::optional< LambdaPtrUseAnalysis >	getDominatingUse (const DataLayout &DL, Value *ValueNeedingAnalysis, Value *SeenUse, int64_t TargetOffset, CallBase *LambdaCB=nullptr)
std::optional< ReturnInst * >	getRetInst (Function &F)
int64_t	getValueIndicesOffset (const DataLayout &DL, Type *AggTy, ArrayRef< unsigned > Indices)
bool	isSamePointerAddress (const DataLayout &DL, Value *LHS, Value *RHS)
void	collectReachingPointerStores (const DataLayout &DL, BasicBlock *BB, Instruction *Before, Value *Address, SmallPtrSetImpl< BasicBlock * > &Visited, ReachingPointerStores &Result)
ReachingPointerStores	getReachingPointerStores (const DataLayout &DL, LoadInst &LI)
Value *	getPointerLoadOrigin (const DataLayout &DL, Value *V, SmallPtrSetImpl< Value * > &Visited)
Value *	getUniqueReachingPointer (const DataLayout &DL, const ReachingPointerStores &Stores, SmallPtrSetImpl< Value * > &Visited)
bool	hasAmbiguousReachingPointers (const DataLayout &DL, const ReachingPointerStores &Stores)
bool	isPointerSpillLoad (const LoadInst &LI)
bool	analyzeLambdaUses (llvm::Module &M, DenseMap< CallBase *, LambdaKernelArgAnalysis > &CallBaseToArgOffset, const SmallVector< CallBase * > &CBToAnalyze)
bool	runLambdaAnalysis (llvm::Module &M)
void	reportFatalError (const llvm::Twine &Reason, const char *FILE, unsigned Line)
void	reportFatalError (const char *Reason, const char *FILE, unsigned Line)
void	reportFatalError (const std::string &Reason, const char *FILE, unsigned Line)
void	reportFatalError (const llvm::StringRef &Reason, const char *FILE, unsigned Line)
llvm::Type *	toLLVMType (const IRType &T, LLVMContext &Ctx)
TargetModelType	parseTargetModel (const std::string &Target)
std::string	getTargetTriple (TargetModelType Model)
bool	isHostTargetModel (TargetModelType TargetModel)
void	init ()
void	finalize ()
void	registerJITPassPlugin (const std::string &PluginPath)
void	registerJITPassPlugin (const std::string &PluginPath, const std::string &PassPipeline)
void	registerJITPassPlugin (const std::string &PluginPath, const std::string &PassPipeline, JITPassPluginPosition Position)
void	clearJITPassPlugins ()
void	enable ()
void	disable ()
constexpr unsigned	toLLVM (AddressSpace AS)
std::string	toString (ScopeKind Kind)
template<typename... Ts>
std::vector< IRType >	unpackArgTypes (ArgTypeList< Ts... >)
bool	isIntegerKind (const IRType &T)
	Returns true when T is an integer kind (Int1, Int16, Int32, or Int64).
bool	isFloatingPointKind (const IRType &T)
	Returns true when T is a floating-point kind (Float or Double).
llvm::Type *	toLLVMType (const IRType &T, llvm::LLVMContext &Ctx)
template<typename T >
llvm::Type *	getLLVMType (llvm::LLVMContext &Ctx, std::size_t NElem=0)
template<typename T >
llvm::Type *	getLLVMPointerElemType (llvm::LLVMContext &Ctx)
template<typename T , typename U >
std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > >	operator+ (const T &ConstValue, const Var< U > &Var)
template<typename T , typename U >
std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > >	operator- (const T &ConstValue, const Var< U > &V)
template<typename T , typename U >
std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > >	operator* (const T &ConstValue, const Var< U > &V)
template<typename T , typename U >
std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > >	operator/ (const T &ConstValue, const Var< U > &V)
template<typename T , typename U >
std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > >	operator% (const T &ConstValue, const Var< U > &V)
template<typename T >
Var< T >	declVar (CodeBuilder &CB, const std::string &Name="var")
template<typename T >
Var< T >	defVar (CodeBuilder &CB, const T &Val, const std::string &Name="var")
template<typename T , typename U >
Var< std::common_type_t< remove_cvref_t< T >, remove_cvref_t< U > > >	binOp (const Var< T > &L, const Var< U > &R, ArithOp Op)
template<typename T , typename U >
Var< T, std::enable_if_t< is_scalar_arithmetic_v< T > > > &	compoundAssignConst (Var< T, std::enable_if_t< is_scalar_arithmetic_v< T > > > &LHS, const U &ConstValue, ArithOp Op)
template<typename T , typename U >
Var< bool >	cmpOp (const Var< T > &L, const Var< U > &R, CmpOp Op)
template<typename T >
Var< float >	powf (const Var< float > &L, const Var< T > &R)
template<typename T >
Var< float >	sqrtf (const Var< T > &R)
template<typename T >
Var< float >	expf (const Var< T > &R)
template<typename T >
Var< float >	sinf (const Var< T > &R)
template<typename T >
Var< float >	cosf (const Var< T > &R)
template<typename T >
Var< float >	fabs (const Var< T > &R)
template<typename T >
Var< float >	truncf (const Var< T > &R)
template<typename T >
Var< float >	logf (const Var< T > &R)
template<typename T >
Var< float >	absf (const Var< T > &R)
template<typename T >
std::enable_if_t< is_arithmetic_unref_v< T >, Var< remove_cvref_t< T > > >	min (const Var< T > &L, const Var< T > &R)
template<typename T >
std::enable_if_t< is_arithmetic_unref_v< T >, Var< remove_cvref_t< T > > >	max (const Var< T > &L, const Var< T > &R)
template<typename T >
	__attribute__ ((noinline)) void jit_arg(T V) noexcept
template<class L >
auto	__attribute__ ((annotate("proteus.register_call"))) register_lambda(L &&lambda) noexcept

Variables
cudaError_t(*	__proteus_cudaGetSymbolAddress_ptr )(void **, const void *) = nullptr
cudaError_t(*	__proteus_cudaLaunchKernel_ptr )(const void *, dim3, dim3, void **, size_t, cudaStream_t) = nullptr
constexpr char	LambdaCallsiteMetadataName [] = "proteus.lambda_callsite"
constexpr char	LambdaSchemaMetadataName [] = "proteus.lambda_schema"
template<typename T >
constexpr bool	is_arithmetic_unref_v
template<typename T >
constexpr bool	is_pointer_unref_v
template<typename T >
constexpr bool	is_scalar_arithmetic_v
template<typename T >
constexpr bool	is_mutable_v
size_t	NumElts
size_t std::remove_pointer< T >::type	Velem = 0) noexcept

Typedef Documentation

LambdaCallsiteLocationMap

using proteus::LambdaCallsiteLocationMap = typedef DenseMap<uint64_t, DenseMap<uint32_t, LambdaKernelArgLocation> >

LambdaCallsiteRuntimeConstants

using proteus::LambdaCallsiteRuntimeConstants = typedef SmallVector<RuntimeConstant, 8>

LambdaCallsiteRuntimeConstantsMap

using proteus::LambdaCallsiteRuntimeConstantsMap = typedef DenseMap<uint64_t, LambdaCallsiteRuntimeConstants>

LambdaKernelArgLocationMap

using proteus::LambdaKernelArgLocationMap = typedef DenseMap<uint64_t, LambdaKernelArgLocationVec>

LambdaKernelArgLocationVec

using proteus::LambdaKernelArgLocationVec = typedef SmallVector<LambdaKernelArgLocation, 4>

remove_cvref_t

template<typename T >

using proteus::remove_cvref_t = typedef std::remove_cv_t<std::remove_reference_t<T> >

Enumeration Type Documentation

AddressSpace

enum class proteus::AddressSpace : unsigned int

strong

Enumerator
DEFAULT
GLOBAL
SHARED
CONSTANT
LOCAL

ArithOp

enum class proteus::ArithOp

strong

Semantic arithmetic operation selector.

Enumerator
Add
Sub
Mul
Div
Rem

CmpOp

enum class proteus::CmpOp

strong

Semantic comparison operation selector.

Enumerator
EQ
NE
LT
LE
GT
GE

CodeBuilderKind

enum class proteus::CodeBuilderKind

strong

Identifies the concrete backend implementation, enabling static_cast dispatch without RTTI.

Enumerator
LLVM
MLIR

CodegenOption

enum class proteus::CodegenOption

strong

Enumerator
RTC
Serial
Parallel

CppJitCompilerBackend

enum class proteus::CppJitCompilerBackend

strong

Enumerator
Clang
Nvcc

EmissionPolicy

enum class proteus::EmissionPolicy

strong

Enumerator
Eager
Lazy

IRTypeKind

enum class proteus::IRTypeKind

strong

Enumerates the primitive IR type kinds understood by Proteus. This enumeration is backend-independent; individual backends (e.g. LLVM, MLIR) are responsible for mapping these kinds to their own type representations.

Enumerator
Void
Int1
Int16
Int32
Int64
Float
Double
Pointer
Array

JitFuncAttribute

enum class proteus::JitFuncAttribute

strong

Enumerator
MaxDynamicSharedMemorySize

JITPassPluginPosition

enum class proteus::JITPassPluginPosition

strong

Enumerator
Prepend
Append

KernelCloneOption

enum class proteus::KernelCloneOption

strong

Enumerator
LinkClonePrune
LinkCloneLight
CrossClone

LLVMIRInputKind

enum class proteus::LLVMIRInputKind

strong

Enumerator
Auto
TextIR
Bitcode

MPITag

enum class proteus::MPITag : int

strong

Enumerator
Store
LookupRequest
LookupResponse

RuntimeConstantType

enum proteus::RuntimeConstantType : int32_t

Enumerator
BEGIN
NONE
BOOL
INT8
INT32
INT64
FLOAT
DOUBLE
LONG_DOUBLE
PTR
STATIC_ARRAY
VECTOR
ARRAY
OBJECT
END

ScopeKind

enum class proteus::ScopeKind

strong

Enumerator
FUNCTION
IF
FOR
WHILE

TargetModelType

enum class proteus::TargetModelType

strong

Enumerator
HOST
CUDA
HIP
HOST_HIP
HOST_CUDA

TraceOption

enum class proteus::TraceOption : unsigned

strong

Enumerator
Specialization
IRDump
KernelTrace
CacheStats

Function Documentation

__attribute__() [1/2]

template<class L >

auto proteus::__attribute__ ( (annotate("proteus.register_call"))  ) &&

inlinenoexcept

__attribute__() [2/2]

template<typename T >

proteus::__attribute__ ( (noinline)  )

noexcept

absf()

template<typename T >

Var< float > proteus::absf

(

const Var< T > &

R

)

analyzeLambdaUses()

bool proteus::analyzeLambdaUses ( llvm::Module &  M, DenseMap< CallBase *, LambdaKernelArgAnalysis > &  CallBaseToArgOffset, const SmallVector< CallBase * > &  CBToAnalyze  )

inline

binOp()

template<typename T , typename U >

Var< std::common_type_t< remove_cvref_t< T >, remove_cvref_t< U > > > proteus::binOp	(	const Var< T > &	L,
		const Var< U > &	R,
		ArithOp	Op
	)

clearJITPassPlugins()

void proteus::clearJITPassPlugins

(

)

clearJITPassPluginsImpl()

void proteus::clearJITPassPluginsImpl

(

)

cloneKernelFromModule()

std::unique_ptr< Module > proteus::cloneKernelFromModule ( Module &  M, StringRef  Name, CallGraph &  CG  )

inline

cloneKernelFromModules()

std::unique_ptr< Module > proteus::cloneKernelFromModules ( ArrayRef< std::reference_wrapper< Module > >  Mods, StringRef  EntryName, function_ref< bool(const GlobalValue *)>  ShouldCloneDefinition = nullptr  )

inline

cmpOp()

template<typename T , typename U >

Var< bool > proteus::cmpOp	(	const Var< T > &	L,
		const Var< U > &	R,
		CmpOp	Op
	)

codegenObject() [1/2]

std::unique_ptr< MemoryBuffer > proteus::codegenObject ( Module &  M, StringRef  DeviceArch, SmallPtrSetImpl< void * > &  GlobalLinkedBinaries, CodegenOption  CGOption = CodegenOption::RTC  )

inline

codegenObject() [2/2]

std::unique_ptr< MemoryBuffer > proteus::codegenObject ( Module &  M, StringRef  DeviceArch, SmallPtrSetImpl< void * > &  GlobalLinkedBinaries, CodegenOption  CGOption = CodegenOption::RTC, const OptimizationPipelineConfig &  OptConfig = OptimizationPipelineConfig(std::nullopt, '3', 3)  )

inline

codegenPTX()

void proteus::codegenPTX ( Module &  M, StringRef  DeviceArch, SmallVectorImpl< char > &  PTXStr  )

inline

collectReachingPointerStores()

void proteus::collectReachingPointerStores ( const DataLayout &  DL, BasicBlock *  BB, Instruction *  Before, Value *  Address, SmallPtrSetImpl< BasicBlock * > &  Visited, ReachingPointerStores &  Result  )

inline

compoundAssignConst()

template<typename T , typename U >

Var< T, std::enable_if_t< is_scalar_arithmetic_v< T > > > & proteus::compoundAssignConst	(	Var< T, std::enable_if_t< is_scalar_arithmetic_v< T > > > &	LHS,
		const U &	ConstValue,
		ArithOp	Op
	)

computeCppJitModuleHash()

HashT proteus::computeCppJitModuleHash	(	TargetModelType	TM,
		CppJitCompilerBackend	Backend,
		const std::string &	Code,
		const std::vector< std::string > &	ExtraArgs
	)

convertRuntimeConstantTypeToLLVMType()

Type * proteus::convertRuntimeConstantTypeToLLVMType ( RuntimeConstantType  RCType, LLVMContext &  Ctx  )

inline

convertTypeToRuntimeConstantType()

RuntimeConstantType proteus::convertTypeToRuntimeConstantType ( Type *  Ty )

inline

cosf()

template<typename T >

Var< float > proteus::cosf

(

const Var< T > &

R

)

createCppJitCompiler()

std::unique_ptr< CppJitCompiler > proteus::createCppJitCompiler

(

const CppJitCompileRequest &

Request

)

createCppJitCompilerClang()

std::unique_ptr< CppJitCompiler > proteus::createCppJitCompilerClang

(

)

declVar()

template<typename T >

Var< T > proteus::declVar	(	CodeBuilder &	CB,
		const std::string &	Name = "var"
	)

defVar()

template<typename T >

Var< T > proteus::defVar	(	CodeBuilder &	CB,
		const T &	Val,
		const std::string &	Name = "var"
	)

disable()

void proteus::disable

(

)

dispatchGetRuntimeConstantValue()

RuntimeConstant proteus::dispatchGetRuntimeConstantValue ( void **  Args, const RuntimeConstantInfo &  RCInfo  )

inline

enable()

void proteus::enable

(

)

expf()

template<typename T >

Var< float > proteus::expf

(

const Var< T > &

R

)

fabs()

template<typename T >

Var< float > proteus::fabs

(

const Var< T > &

R

)

finalize()

void proteus::finalize

(

)

findFunctionsWithU64Metadata() [1/2]

void proteus::findFunctionsWithU64Metadata ( llvm::Module &  M, llvm::StringRef  Key, llvm::SmallVectorImpl< std::pair< llvm::Function *, std::uint64_t > > &  Out  )

inline

findFunctionsWithU64Metadata() [2/2]

void proteus::findFunctionsWithU64Metadata ( llvm::Module &  M, llvm::StringRef  Key, llvm::SmallVectorImpl< std::uint64_t > &  Out  )

inline

getCanonicalSourceFileName()

std::string proteus::getCanonicalSourceFileName ( Module &  M )

inline

getConstant()

Constant * proteus::getConstant ( LLVMContext &  Ctx, Type *  ArgType, const RuntimeConstant &  RC  )

inline

getDefaultValueFromOptional()

template<typename T >

T proteus::getDefaultValueFromOptional	(	std::optional< T >	JSONValue,
		T	Default
	)

getDominatingUse()

std::optional< LambdaPtrUseAnalysis > proteus::getDominatingUse ( const DataLayout &  DL, Value *  ValueNeedingAnalysis, Value *  SeenUse, int64_t  TargetOffset, CallBase *  LambdaCB = nullptr  )

inline

getEnvOrDefaultBool()

bool proteus::getEnvOrDefaultBool ( const char *  VarName, bool  Default  )

inline

getEnvOrDefaultCG()

CodegenOption proteus::getEnvOrDefaultCG ( const char *  VarName, CodegenOption  Default  )

inline

getEnvOrDefaultChar()

char proteus::getEnvOrDefaultChar ( const char *  VarName, char  Default  )

inline

getEnvOrDefaultInt()

int proteus::getEnvOrDefaultInt ( const char *  VarName, int  Default  )

inline

getEnvOrDefaultKC()

KernelCloneOption proteus::getEnvOrDefaultKC ( const char *  VarName, KernelCloneOption  Default  )

inline

getEnvOrDefaultString()

std::optional< std::string > proteus::getEnvOrDefaultString ( const char *  VarName )

inline

getFunctionU64Metadata()

std::optional< uint64_t > proteus::getFunctionU64Metadata ( Function &  F, StringRef  Key  )

inline

getJITPassPluginConfigs()

std::vector< JITPassPluginConfig > proteus::getJITPassPluginConfigs

(

)

getKernelFunctionFromImage()

hipFunction_t proteus::getKernelFunctionFromImage ( StringRef  KernelName, const void *  Image, bool  RelinkGlobalsByCopy, const std::unordered_map< std::string, GlobalVarInfo > &  VarNameToGlobalInfo  )

inline

getLambdaCallsiteIndex()

std::optional< uint32_t > proteus::getLambdaCallsiteIndex ( const CallBase &  CB, uint64_t  ExpectedLambdaID  )

inline

getLambdaCallsiteMetadata()

std::optional< std::pair< uint64_t, uint32_t > > proteus::getLambdaCallsiteMetadata ( const CallBase &  CB )

inline

getLLVMPointerElemType()

template<typename T >

llvm::Type * proteus::getLLVMPointerElemType

(

llvm::LLVMContext &

Ctx

)

Return the llvm::Type* of the element type for a C++ pointer type T, or nullptr when T is not a pointer type. This is the LLVM-backend counterpart of TypeMap<T>::getPointerElemType().

getLLVMType()

template<typename T >

llvm::Type * proteus::getLLVMType	(	llvm::LLVMContext &	Ctx,
		std::size_t	NElem = 0
	)

Return the llvm::Type* for a C++ type T. This is the LLVM-backend counterpart of TypeMap<T>::get().

getOrderedLambdaKernelArgLocations()

LambdaKernelArgLocationVec proteus::getOrderedLambdaKernelArgLocations ( const DenseMap< uint32_t, LambdaKernelArgLocation > &  CallsiteLocations )

inline

getPointerLoadOrigin()

Value * proteus::getPointerLoadOrigin ( const DataLayout &  DL, Value *  V, SmallPtrSetImpl< Value * > &  Visited  )

inline

getPreviousCoveringStore()

std::optional< LambdaPtrUseAnalysis > proteus::getPreviousCoveringStore ( const DataLayout &  DL, Value *  Ptr, Value *  UseBoundary, int64_t  TargetOffset  )

inline

getReachingPointerStores()

ReachingPointerStores proteus::getReachingPointerStores ( const DataLayout &  DL, LoadInst &  LI  )

inline

getRetInst()

std::optional< ReturnInst * > proteus::getRetInst

(

Function &

F

)

getRuntimeConstantValue()

template<typename T >

T proteus::getRuntimeConstantValue ( void *  Arg )

inline

getSizeInBytes()

size_t proteus::getSizeInBytes ( RuntimeConstantType  RCType )

inline

getTargetTriple()

std::string proteus::getTargetTriple

(

TargetModelType

Model

)

getTrackedPointerLocation()

std::optional< MemoryLocation > proteus::getTrackedPointerLocation ( const DataLayout &  DL, Value *  Ptr  )

inline

getTypeStoreSize()

std::optional< uint64_t > proteus::getTypeStoreSize ( const DataLayout &  DL, Type *  Ty  )

inline

getUniqueFileID()

std::string proteus::getUniqueFileID ( Module &  M )

inline

getUniqueReachingPointer()

Value * proteus::getUniqueReachingPointer ( const DataLayout &  DL, const ReachingPointerStores &  Stores, SmallPtrSetImpl< Value * > &  Visited  )

inline

getValue()

template<typename T >

T proteus::getValue

(

const RuntimeConstant &

RC

)

getValueIndicesOffset()

int64_t proteus::getValueIndicesOffset ( const DataLayout &  DL, Type *  AggTy, ArrayRef< unsigned >  Indices  )

inline

hasAmbiguousReachingPointers()

bool proteus::hasAmbiguousReachingPointers ( const DataLayout &  DL, const ReachingPointerStores &  Stores  )

inline

hash() [1/2]

template<typename FirstT , typename... RestTs>

HashT proteus::hash ( FirstT &&  First, RestTs &&...  Rest  )

inline

hash() [2/2]

template<typename T >

HashT proteus::hash ( T &&  Data )

inline

hashArrayRefElement()

HashT proteus::hashArrayRefElement ( const RuntimeConstant &  RC )

inline

hashCodeGenConfig()

HashT proteus::hashCodeGenConfig ( const CodeGenerationConfig &  CGConfig )

inline

hashCombine()

HashT proteus::hashCombine ( HashT  A, HashT  B  )

inline

hashRuntimeConstantArray()

template<typename T >

HashT proteus::hashRuntimeConstantArray ( const RuntimeConstant &  RC )

inline

hashRuntimeConstantObject()

HashT proteus::hashRuntimeConstantObject ( const RuntimeConstant &  RC )

inline

hashRuntimeSpecializationConfig()

HashT proteus::hashRuntimeSpecializationConfig ( const CodeGenerationConfig &  CGConfig )

inline

hashValue() [1/11]

HashT proteus::hashValue ( ArrayRef< RuntimeConstant >  Arr )

inline

hashValue() [2/11]

template<typename T >

HashT proteus::hashValue ( ArrayRef< T >  Arr )

inline

hashValue() [3/11]

HashT proteus::hashValue ( const CodeGenerationConfig &  CGConfig )

inline

hashValue() [4/11]

template<typename Key , typename Value >

std::enable_if_t< std::is_integral< Key >::value||std::is_enum< Key >::value, HashT > proteus::hashValue ( const DenseMap< Key, Value > &  Map )

inline

hashValue() [5/11]

HashT proteus::hashValue ( const HashT &  H )

inline

hashValue() [6/11]

HashT proteus::hashValue ( const RuntimeConstant &  RC )

inline

hashValue() [7/11]

template<typename T , unsigned N>

HashT proteus::hashValue ( const SmallVector< T, N > &  Vec )

inline

hashValue() [8/11]

HashT proteus::hashValue ( const std::string &  S )

inline

hashValue() [9/11]

HashT proteus::hashValue ( const StringRef &  S )

inline

hashValue() [10/11]

template<typename T >

std::enable_if_t< std::is_scalar< T >::value, HashT > proteus::hashValue ( const T &  V )

inline

hashValue() [11/11]

template<typename Key , typename Value >

HashT proteus::hashValue ( DenseMap< Key, Value > &  Map )

inline

hasU64Metadata()

bool proteus::hasU64Metadata ( Function *  F, StringRef  Key  )

inline

init()

void proteus::init

(

)

internalize()

void proteus::internalize ( Module &  M, StringRef  PreserveFunctionName  )

inline

isDebugOutputEnabled()

bool proteus::isDebugOutputEnabled ( )

inline

isDeviceCompilation()

bool proteus::isDeviceCompilation ( Module &  M )

inline

isDeviceKernel()

bool proteus::isDeviceKernel ( const Function *  F )

inline

isFloatingPointKind()

bool proteus::isFloatingPointKind ( const IRType &  T )

inline

Returns true when T is a floating-point kind (Float or Double).

isHostTargetModel()

bool proteus::isHostTargetModel

(

TargetModelType

TargetModel

)

isIntegerKind()

bool proteus::isIntegerKind ( const IRType &  T )

inline

Returns true when T is an integer kind (Int1, Int16, Int32, or Int64).

isPointerSpillLoad()

bool proteus::isPointerSpillLoad ( const LoadInst &  LI )

inline

isSamePointerAddress()

bool proteus::isSamePointerAddress ( const DataLayout &  DL, Value *  LHS, Value *  RHS  )

inline

isScalarRuntimeConstantType()

bool proteus::isScalarRuntimeConstantType ( RuntimeConstantType  RCType )

inline

launchKernelDirect() [1/2]

cudaError_t proteus::launchKernelDirect ( void *  KernelFunc, dim3  GridDim, dim3  BlockDim, void **  KernelArgs, uint64_t  ShmemSize, CUstream  Stream  )

inline

launchKernelDirect() [2/2]

hipError_t proteus::launchKernelDirect ( void *  KernelFunc, dim3  GridDim, dim3  BlockDim, void **  KernelArgs, uint64_t  ShmemSize, hipStream_t  Stream  )

inline

launchKernelFunction() [1/2]

cudaError_t proteus::launchKernelFunction ( CUfunction  KernelFunc, dim3  GridDim, dim3  BlockDim, void **  KernelArgs, uint64_t  ShmemSize, CUstream  Stream  )

inline

launchKernelFunction() [2/2]

hipError_t proteus::launchKernelFunction ( hipFunction_t  KernelFunc, dim3  GridDim, dim3  BlockDim, void **  KernelArgs, uint64_t  ShmemSize, hipStream_t  Stream  )

inline

linkModules()

std::unique_ptr< Module > proteus::linkModules ( LLVMContext &  Ctx, SmallVector< std::unique_ptr< Module > >  LinkedModules  )

inline

loadMLIRLoweringDialects()

void proteus::loadMLIRLoweringDialects

(

mlir::MLIRContext &

Context

)

logf()

template<typename T >

Var< float > proteus::logf

(

const Var< T > &

R

)

lowerMLIRModuleToLLVM()

MLIRLoweringResult proteus::lowerMLIRModuleToLLVM	(	mlir::ModuleOp	Module,
		const MLIRLoweringOptions &	Options
	)

max()

template<typename T >

std::enable_if_t< is_arithmetic_unref_v< T >, Var< remove_cvref_t< T > > > proteus::max	(	const Var< T > &	L,
		const Var< T > &	R
	)

min()

template<typename T >

std::enable_if_t< is_arithmetic_unref_v< T >, Var< remove_cvref_t< T > > > proteus::min	(	const Var< T > &	L,
		const Var< T > &	R
	)

needsDefUseAnalysis()

bool proteus::needsDefUseAnalysis

(

Value *

Val

)

offsetCoveredByRange()

bool proteus::offsetCoveredByRange ( int64_t  TargetOffset, int64_t  RangeOffset, uint64_t  RangeSize  )

inline

operator%()

template<typename T , typename U >

std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > > proteus::operator%	(	const T &	ConstValue,
		const Var< U > &	V
	)

operator*()

template<typename T , typename U >

std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > > proteus::operator*	(	const T &	ConstValue,
		const Var< U > &	V
	)

operator+()

template<typename T , typename U >

std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > > proteus::operator+	(	const T &	ConstValue,
		const Var< U > &	Var
	)

operator-()

template<typename T , typename U >

std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > > proteus::operator-	(	const T &	ConstValue,
		const Var< U > &	V
	)

operator/()

template<typename T , typename U >

std::enable_if_t< std::is_arithmetic_v< T > &&std::is_arithmetic_v< U >, Var< std::common_type_t< T, U > > > proteus::operator/	(	const T &	ConstValue,
		const Var< U > &	V
	)

optimizeIR()

void proteus::optimizeIR ( Module &  M, StringRef  Arch, const OptimizationPipelineConfig &  OptConfig  )

inline

packStoreMessage()

std::vector< char > proteus::packStoreMessage	(	MPI_Comm	Comm,
		const HashT &	HashValue,
		const CacheEntry &	Entry
	)

parseJSONConfig()

llvm::StringMap< const CodeGenerationConfig > proteus::parseJSONConfig ( std::optional< std::string >  JSONFn )

inline

parseTargetModel()

TargetModelType proteus::parseTargetModel

(

const std::string &

Target

)

parseTraceConfig()

unsigned proteus::parseTraceConfig ( const char *  VarName )

inline

powf()

template<typename T >

Var< float > proteus::powf	(	const Var< float > &	L,
		const Var< T > &	R
	)

pruneDanglingNVVMAnnotations()

void proteus::pruneDanglingNVVMAnnotations ( Module &  M )

inline

pruneIR()

void proteus::pruneIR ( Module &  M, bool  UnsetExternallyInitialized = true  )

inline

registerJITPassPlugin() [1/3]

void proteus::registerJITPassPlugin

(

const std::string &

PluginPath

)

registerJITPassPlugin() [2/3]

void proteus::registerJITPassPlugin	(	const std::string &	PluginPath,
		const std::string &	PassPipeline
	)

registerJITPassPlugin() [3/3]

void proteus::registerJITPassPlugin	(	const std::string &	PluginPath,
		const std::string &	PassPipeline,
		JITPassPluginPosition	Position
	)

registerJITPassPluginImpl()

void proteus::registerJITPassPluginImpl	(	const std::string &	PluginPath,
		std::optional< JITPassPluginInsertion >	Insertion
	)

registerMLIRLoweringDialects()

void proteus::registerMLIRLoweringDialects

(

mlir::DialectRegistry &

Registry

)

reportFatalError() [1/4]

void proteus::reportFatalError	(	const char *	Reason,
		const char *	FILE,
		unsigned	Line
	)

reportFatalError() [2/4]

void proteus::reportFatalError	(	const llvm::StringRef &	Reason,
		const char *	FILE,
		unsigned	Line
	)

reportFatalError() [3/4]

void proteus::reportFatalError	(	const llvm::Twine &	Reason,
		const char *	FILE,
		unsigned	Line
	)

reportFatalError() [4/4]

void proteus::reportFatalError	(	const std::string &	Reason,
		const char *	FILE,
		unsigned	Line
	)

resolveClangxx()

const ResolvedToolPath & proteus::resolveClangxx

(

)

resolveCUDAToolchain()

const ResolvedCUDAToolchain & proteus::resolveCUDAToolchain

(

)

resolveDeviceGlobalAddr()

void * proteus::resolveDeviceGlobalAddr ( const void *  Addr )

inline

resolveHIPToolchain()

const ResolvedHIPToolchain & proteus::resolveHIPToolchain

(

)

runCleanupPassPipeline()

void proteus::runCleanupPassPipeline ( Module &  M )

inline

runLambdaAnalysis()

bool proteus::runLambdaAnalysis

(

llvm::Module &

M

)

setFuncAttribute()

void proteus::setFuncAttribute	(	TargetModelType	TargetModel,
		void *	KernelFunc,
		JitFuncAttribute	Attr,
		int	Value
	)

setLambdaCallsiteMetadata()

void proteus::setLambdaCallsiteMetadata ( CallBase &  CB, uint64_t  LambdaID, uint32_t  CallsiteIndex  )

inline

setLaunchBoundsForKernel()

void proteus::setLaunchBoundsForKernel ( Function &  F, int  MaxThreadsPerSM, int  MinBlocksPerSM = 0  )

inline

sinf()

template<typename T >

Var< float > proteus::sinf

(

const Var< T > &

R

)

sqrtf()

template<typename T >

Var< float > proteus::sqrtf

(

const Var< T > &

R

)

strToCG()

CodegenOption proteus::strToCG ( std::string  CGstr )

inline

toLLVM()

constexpr unsigned proteus::toLLVM ( AddressSpace  AS )

inlineconstexpr

toLLVMType() [1/2]

llvm::Type * proteus::toLLVMType	(	const IRType &	T,
		llvm::LLVMContext &	Ctx
	)

Convert a backend-independent IRType descriptor to its corresponding llvm::Type*.

Parameters

T	The abstract type descriptor produced by TypeMap<T>::get().
Ctx	The LLVM context to use when constructing the type.

Returns

The corresponding llvm::Type*, or nullptr when T represents an element type absent in the Pointer/Array descriptor (i.e. IRTypeKind::Void in that position).

toLLVMType() [2/2]

llvm::Type * proteus::toLLVMType	(	const IRType &	T,
		LLVMContext &	Ctx
	)

toString() [1/5]

std::string proteus::toString ( CodegenOption  Option )

inline

toString() [2/5]

std::string proteus::toString ( const RuntimeConstantType  RCType )

inline

toString() [3/5]

std::string proteus::toString ( KernelCloneOption  Option )

inline

toString() [4/5]

std::string proteus::toString ( ScopeKind  Kind )

inline

toString() [5/5]

std::string proteus::toString ( Value &  V )

inline

truncf()

template<typename T >

Var< float > proteus::truncf

(

const Var< T > &

R

)

unpackArgTypes()

template<typename... Ts>

std::vector< IRType > proteus::unpackArgTypes

(

ArgTypeList< Ts... >

)

unpackStoreMessage()

StoreMessage proteus::unpackStoreMessage	(	MPI_Comm	Comm,
		const std::vector< char > &	Buffer
	)

validateMPIConfig()

void proteus::validateMPIConfig

(

)

Variable Documentation

__proteus_cudaGetSymbolAddress_ptr

cudaError_t(* proteus::__proteus_cudaGetSymbolAddress_ptr) (void **, const void *) ( void **  , const void *    ) = nullptr

inline

__proteus_cudaLaunchKernel_ptr

cudaError_t(* proteus::__proteus_cudaLaunchKernel_ptr) (const void *, dim3, dim3, void **, size_t, cudaStream_t) ( const void *  , dim3  , dim3  , void **  , size_t  , cudaStream_t    ) = nullptr

inline

is_arithmetic_unref_v

template<typename T >

constexpr bool proteus::is_arithmetic_unref_v

inlineconstexpr

Initial value:

=
    std::is_arithmetic_v<std::remove_reference_t<T>>

is_mutable_v

template<typename T >

constexpr bool proteus::is_mutable_v

inlineconstexpr

Initial value:

=
    !std::is_const_v<std::remove_reference_t<T>>

is_pointer_unref_v

template<typename T >

constexpr bool proteus::is_pointer_unref_v

inlineconstexpr

Initial value:

=
    std::is_pointer_v<std::remove_reference_t<T>>

is_scalar_arithmetic_v

template<typename T >

constexpr bool proteus::is_scalar_arithmetic_v

inlineconstexpr

Initial value:

=
    std::is_arithmetic_v<std::remove_reference_t<T>> &&
    !std::is_pointer_v<std::remove_reference_t<T>> &&
    !std::is_array_v<std::remove_reference_t<T>>

LambdaCallsiteMetadataName

constexpr char proteus::LambdaCallsiteMetadataName[] = "proteus.lambda_callsite"

inlineconstexpr

LambdaSchemaMetadataName

constexpr char proteus::LambdaSchemaMetadataName[] = "proteus.lambda_schema"

inlineconstexpr

NumElts

size_t proteus::NumElts

Velem

size_t std::remove_pointer<T>::type proteus::Velem = 0) noexcept