LLVM  9.0.0svn
LegacyDivergenceAnalysis.h
Go to the documentation of this file.
1 //===- llvm/Analysis/LegacyDivergenceAnalysis.h - KernelDivergence Analysis -*- 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 // The kernel divergence analysis is an LLVM pass which can be used to find out
10 // if a branch instruction in a GPU program (kernel) is divergent or not. It can help
11 // branch optimizations such as jump threading and loop unswitching to make
12 // better decisions.
13 //
14 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_ANALYSIS_LEGACY_DIVERGENCE_ANALYSIS_H
16 #define LLVM_ANALYSIS_LEGACY_DIVERGENCE_ANALYSIS_H
17 
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/Pass.h"
22 
23 namespace llvm {
24 class Value;
25 class GPUDivergenceAnalysis;
27 public:
28  static char ID;
29 
32  }
33 
34  void getAnalysisUsage(AnalysisUsage &AU) const override;
35 
36  bool runOnFunction(Function &F) override;
37 
38  // Print all divergent branches in the function.
39  void print(raw_ostream &OS, const Module *) const override;
40 
41  // Returns true if V is divergent at its definition.
42  //
43  // Even if this function returns false, V may still be divergent when used
44  // in a different basic block.
45  bool isDivergent(const Value *V) const;
46 
47  // Returns true if V is uniform/non-divergent.
48  //
49  // Even if this function returns true, V may still be divergent when used
50  // in a different basic block.
51  bool isUniform(const Value *V) const { return !isDivergent(V); }
52 
53  // Keep the analysis results uptodate by removing an erased value.
54  void removeValue(const Value *V) { DivergentValues.erase(V); }
55 
56 private:
57  // Whether analysis should be performed by GPUDivergenceAnalysis.
58  bool shouldUseGPUDivergenceAnalysis(const Function &F) const;
59 
60  // (optional) handle to new DivergenceAnalysis
61  std::unique_ptr<GPUDivergenceAnalysis> gpuDA;
62 
63  // Stores all divergent values.
64  DenseSet<const Value *> DivergentValues;
65 };
66 } // End llvm namespace
67 
68 #endif //LLVM_ANALYSIS_LEGACY_DIVERGENCE_ANALYSIS_H
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
void print(raw_ostream &OS, const Module *) const override
print - Print out the internal state of the pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
bool isDivergent(const Value *V) const
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
bool erase(const ValueT &V)
Definition: DenseSet.h:95
F(f)
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
LLVM Value Representation.
Definition: Value.h:72
bool isUniform(const Value *V) const
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
void initializeLegacyDivergenceAnalysisPass(PassRegistry &)