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)"

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
using	CycleT = typename CycleInfoT::CycleT
using	SyncDependenceAnalysisT = GenericSyncDependenceAnalysis
using	DivergenceDescriptorT
using	BlockLabelMapT = typename SyncDependenceAnalysisT::BlockLabelMap
using	TemporalDivergenceTuple

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
void	recordTemporalDivergence (ConstValueRefT, const InstructionT , const CycleT )
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 Member Functions
void	analyzeControlDivergence (const InstructionT &Term)
	Mark Term as divergent and push all Instructions that become divergent as a result on the worklist.

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 330 of file GenericUniformityImpl.h.

◆ BlockLabelMapT

template

◆ BlockT

template

◆ ConstValueRefT

template

◆ CycleInfoT

template

◆ CycleT

template

◆ DivergenceDescriptorT

template

◆ DominatorTreeT

template

◆ FunctionT

template

◆ InstructionT

template

◆ SyncDependenceAnalysisT

template

◆ TemporalDivergenceTuple

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 1052 of file GenericUniformityImpl.h.

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

Referenced by compute().

◆ compute()

◆ 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.

Referenced by markDivergent().

◆ markDefsDivergent() [3/3]

◆ markDivergent() [1/2]

◆ markDivergent() [2/2]

◆ print()

◆ recordTemporalDivergence()

◆ CI

template

◆ Context

template

◆ DivergentTermBlocks

template

◆ DivergentValues

template

◆ F

template

◆ TemporalDivergenceList

template

◆ TTI

template

◆ Worklist

template

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

include/llvm/ADT/GenericUniformityImpl.h