LLVM: llvm::GenericUniformityAnalysisImpl< ContextT > Class Template Reference (original) (raw)

Analysis that identifies uniform values in a data-parallel execution. More...

#include "[llvm/ADT/GenericUniformityImpl.h](GenericUniformityImpl%5F8h%5Fsource.html)"

Classes
struct	PhiInput
	Value/block pair representing a single phi input. More...

Public Types
using	BlockT = typename ContextT::BlockT

using	FunctionT = typename ContextT::FunctionT

using	ValueRefT = typename ContextT::ValueRefT

using	ConstValueRefT = typename ContextT::ConstValueRefT

using	UseT = typename ContextT::UseT

using	InstructionT = typename ContextT::InstructionT

using	DominatorTreeT = typename ContextT::DominatorTreeT

using	CycleInfoT = GenericCycleInfo< ContextT >

using	CycleT = typename CycleInfoT::CycleT

using	SyncDependenceAnalysisT = GenericSyncDependenceAnalysis< ContextT >

using	DivergenceDescriptorT = typename SyncDependenceAnalysisT::DivergenceDescriptor

using	BlockLabelMapT = typename SyncDependenceAnalysisT::BlockLabelMap

Public Member Functions
	GenericUniformityAnalysisImpl (const DominatorTreeT &DT, const CycleInfoT &CI, const TargetTransformInfo *TTI)

void	initialize ()

const FunctionT &	getFunction () const

void	addUniformOverride (const InstructionT &Instr)
	Mark UniVal as a value that is always uniform.

void	markDivergent (const InstructionT &I)
	Examine I for divergent outputs and add to the worklist.

bool	markDivergent (ConstValueRefT DivVal)
	Mark DivVal as a divergent value.

bool	markDefsDivergent (const InstructionT &Instr)
	Mark outputs of Instr as divergent.

void	compute ()
	Propagate divergence to all instructions in the region.

bool	hasDivergence () const
	Whether any value was marked or analyzed to be divergent.

bool	isAlwaysUniform (const InstructionT &Instr) const
	Whether Val will always return a uniform value regardless of its operands.

bool	hasDivergentDefs (const InstructionT &I) const

bool	isDivergent (const InstructionT &I) const

bool	isDivergent (ConstValueRefT V) const
	Whether Val is divergent at its definition.

bool	isDivergentUse (const UseT &U) const

bool	hasDivergentTerminator (const BlockT &B) const

void	print (raw_ostream &out) const

bool	hasDivergentDefs (const Instruction &I) const

bool	markDefsDivergent (const Instruction &Instr)

void	initialize ()

bool	isDivergentUse (const Use &U) const

bool	hasDivergentDefs (const MachineInstr &I) const

bool	markDefsDivergent (const MachineInstr &Instr)

void	initialize ()

bool	isDivergentUse (const MachineOperand &U) const

Protected Attributes
const ContextT &	Context

const FunctionT &	F

const CycleInfoT &	CI

const TargetTransformInfo *	TTI = nullptr

DenseSet< ConstValueRefT >	DivergentValues

SmallPtrSet< const BlockT *, 32 >	DivergentTermBlocks

std::vector< const InstructionT * >	Worklist

template
class llvm::GenericUniformityAnalysisImpl< ContextT >

Analysis that identifies uniform values in a data-parallel execution.

This analysis propagates divergence in a data-parallel context from sources of divergence to all users. It can be instantiated for an IR that provides a suitable SSAContext.

Definition at line 327 of file GenericUniformityImpl.h.

◆ BlockLabelMapT

template

◆ BlockT

template

◆ ConstValueRefT

template

◆ CycleInfoT

template

◆ CycleT

template

◆ DivergenceDescriptorT

template

◆ DominatorTreeT

template

◆ FunctionT

template

◆ InstructionT

template

◆ SyncDependenceAnalysisT

template

◆ UseT

template

◆ ValueRefT

template

◆ addUniformOverride()

◆ analyzeControlDivergence()

template

Mark Term as divergent and push all Instructions that become divergent as a result on the worklist.

Definition at line 1049 of file GenericUniformityImpl.h.

References A, assert(), B, llvm::CallingConv::C, llvm::dbgs(), llvm::getOutermostDivergentCycle(), llvm::insertIfNotContained(), llvm::DominatorTree::isReachableFromEntry(), LLVM_DEBUG, llvm::SmallVectorTemplateBase< T, bool >::push_back(), and llvm::sort().

◆ compute()

template

◆ getFunction()

template

◆ hasDivergence()

template

◆ hasDivergentDefs() [1/3]

◆ hasDivergentDefs() [2/3]

◆ hasDivergentDefs() [3/3]

◆ hasDivergentTerminator()

template

◆ initialize() [1/3]

◆ initialize() [2/3]

◆ initialize() [3/3]

◆ isAlwaysUniform()

◆ isDivergent() [1/2]

template

◆ isDivergent() [2/2]

template

◆ isDivergentUse() [1/3]

◆ isDivergentUse() [2/3]

◆ isDivergentUse() [3/3]

◆ markDefsDivergent() [1/3]

◆ markDefsDivergent() [2/3]

Mark outputs of Instr as divergent.

Returns

Whether the tracked divergence state of any output has changed.

◆ markDefsDivergent() [3/3]

◆ markDivergent() [1/2]

◆ markDivergent() [2/2]

◆ print()

◆ CI

template

◆ Context

template

◆ DivergentTermBlocks

template

◆ DivergentValues

template

◆ F

template

◆ TTI

template

◆ Worklist

template

The documentation for this class was generated from the following file:

include/llvm/ADT/GenericUniformityImpl.h