| //===- ProfileDataLoader.h - Load & convert profile info ----*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // The ProfileDataLoader class is used to load profiling data from a dump file. |
| // The ProfileDataT<FType, BType> class is used to store the mapping of this |
| // data to control flow edges. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_ANALYSIS_PROFILEDATALOADER_H |
| #define LLVM_ANALYSIS_PROFILEDATALOADER_H |
| |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/DenseMap.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include <string> |
| |
| namespace llvm { |
| |
| class ModulePass; |
| class Function; |
| class BasicBlock; |
| |
| // Helper for dumping edges to dbgs(). |
| raw_ostream& operator<<(raw_ostream &O, std::pair<const BasicBlock *, |
| const BasicBlock *> E); |
| |
| /// \brief The ProfileDataT<FType, BType> class is used to store the mapping of |
| /// profiling data to control flow edges. |
| /// |
| /// An edge is defined by its source and sink basic blocks. |
| template<class FType, class BType> |
| class ProfileDataT { |
| public: |
| // The profiling information defines an Edge by its source and sink basic |
| // blocks. |
| typedef std::pair<const BType*, const BType*> Edge; |
| |
| private: |
| typedef DenseMap<Edge, unsigned> EdgeWeights; |
| |
| /// \brief Count the number of times a transition between two blocks is |
| /// executed. |
| /// |
| /// As a special case, we also hold an edge from the null BasicBlock to the |
| /// entry block to indicate how many times the function was entered. |
| DenseMap<const FType*, EdgeWeights> EdgeInformation; |
| |
| public: |
| /// getFunction() - Returns the Function for an Edge. |
| static const FType *getFunction(Edge e) { |
| // e.first may be NULL |
| assert(((!e.first) || (e.first->getParent() == e.second->getParent())) |
| && "A ProfileData::Edge can not be between two functions"); |
| assert(e.second && "A ProfileData::Edge must have a real sink"); |
| return e.second->getParent(); |
| } |
| |
| /// getEdge() - Creates an Edge between two BasicBlocks. |
| static Edge getEdge(const BType *Src, const BType *Dest) { |
| return Edge(Src, Dest); |
| } |
| |
| /// getEdgeWeight - Return the number of times that a given edge was |
| /// executed. |
| unsigned getEdgeWeight(Edge e) const { |
| const FType *f = getFunction(e); |
| assert((EdgeInformation.find(f) != EdgeInformation.end()) |
| && "No profiling information for function"); |
| EdgeWeights weights = EdgeInformation.find(f)->second; |
| |
| assert((weights.find(e) != weights.end()) |
| && "No profiling information for edge"); |
| return weights.find(e)->second; |
| } |
| |
| /// addEdgeWeight - Add 'weight' to the already stored execution count for |
| /// this edge. |
| void addEdgeWeight(Edge e, unsigned weight) { |
| EdgeInformation[getFunction(e)][e] += weight; |
| } |
| }; |
| |
| typedef ProfileDataT<Function, BasicBlock> ProfileData; |
| //typedef ProfileDataT<MachineFunction, MachineBasicBlock> MachineProfileData; |
| |
| /// The ProfileDataLoader class is used to load raw profiling data from the |
| /// dump file. |
| class ProfileDataLoader { |
| private: |
| /// The name of the file where the raw profiling data is stored. |
| const std::string &Filename; |
| |
| /// A vector of the command line arguments used when the target program was |
| /// run to generate profiling data. One entry per program run. |
| SmallVector<std::string, 1> CommandLines; |
| |
| /// The raw values for how many times each edge was traversed, values from |
| /// multiple program runs are accumulated. |
| SmallVector<unsigned, 32> EdgeCounts; |
| |
| public: |
| /// ProfileDataLoader ctor - Read the specified profiling data file, exiting |
| /// the program if the file is invalid or broken. |
| ProfileDataLoader(const char *ToolName, const std::string &Filename); |
| |
| /// A special value used to represent the weight of an edge which has not |
| /// been counted yet. |
| static const unsigned Uncounted; |
| |
| /// getNumExecutions - Return the number of times the target program was run |
| /// to generate this profiling data. |
| unsigned getNumExecutions() const { return CommandLines.size(); } |
| |
| /// getExecution - Return the command line parameters used to generate the |
| /// i'th set of profiling data. |
| const std::string &getExecution(unsigned i) const { return CommandLines[i]; } |
| |
| const std::string &getFileName() const { return Filename; } |
| |
| /// getRawEdgeCounts - Return the raw profiling data, this is just a list of |
| /// numbers with no mappings to edges. |
| ArrayRef<unsigned> getRawEdgeCounts() const { return EdgeCounts; } |
| }; |
| |
| /// createProfileMetadataLoaderPass - This function returns a Pass that loads |
| /// the profiling information for the module from the specified filename. |
| ModulePass *createProfileMetadataLoaderPass(const std::string &Filename); |
| |
| } // End llvm namespace |
| |
| #endif |