[profi] Move out base definitions into SampleProfileInferenceBase header

[Amir]

Summary

BOLT doesn't require LLVM IR/MIR definitions from SampleProfileInference.
Move out FlowBlock/FlowJump/FlowFunction definitions into a separate header.
This helps avoid TransformUtils link-time dependency.

bolt/lib/Profile/CMakeLists.txt

 add_llvm_library(LLVMBOLTProfile
   BoltAddressTranslation.cpp
   DataAggregator.cpp
   DataReader.cpp
   Heatmap.cpp
   ProfileReaderBase.cpp
   StaleProfileMatching.cpp
   YAMLProfileReader.cpp
   YAMLProfileWriter.cpp
 
   DISABLE_LLVM_LINK_LLVM_DYLIB
 
   LINK_COMPONENTS
   Support
-  TransformUtils
   )
 
 target_link_libraries(LLVMBOLTProfile
   PRIVATE
   LLVMBOLTCore
   LLVMBOLTPasses
   LLVMBOLTUtils
   )

bolt/lib/Profile/StaleProfileMatching.cpp

 //   profile data but the majority (e.g., >90%) of CFGs get the correct counts.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Core/HashUtilities.h"
 #include "bolt/Profile/YAMLProfileReader.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Transforms/Utils/SampleProfileInference.h"
+#include "llvm/Transforms/Utils/SampleProfileInferenceBase.h"
 
 #include <queue>
 
 using namespace llvm;
 
 namespace opts {
 
 extern cl::OptionCategory BoltOptCategory;

llvm/include/llvm/Transforms/Utils/SampleProfileInference.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_SAMPLEPROFILEINFERENCE_H
 #define LLVM_TRANSFORMS_UTILS_SAMPLEPROFILEINFERENCE_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Transforms/Utils/SampleProfileInferenceBase.h"
 
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 
 namespace llvm {
 
 class Function;

 };
 template <> struct TypeMap<MachineBasicBlock> {
   using BasicBlockT = MachineBasicBlock;
   using FunctionT = MachineFunction;
 };
 
 } // end namespace afdo_detail
 
-struct FlowJump;
-
-/// A wrapper of a binary basic block.
-struct FlowBlock {
-  uint64_t Index;
-  uint64_t Weight{0};
-  bool HasUnknownWeight{true};
-  bool IsUnlikely{false};
-  uint64_t Flow{0};
-  std::vector<FlowJump *> SuccJumps;
-  std::vector<FlowJump *> PredJumps;
-
-  /// Check if it is the entry block in the function.
-  bool isEntry() const { return PredJumps.empty(); }
-
-  /// Check if it is an exit block in the function.
-  bool isExit() const { return SuccJumps.empty(); }
-};
-
-/// A wrapper of a jump between two basic blocks.
-struct FlowJump {
-  uint64_t Source;
-  uint64_t Target;
-  uint64_t Weight{0};
-  bool HasUnknownWeight{true};
-  bool IsUnlikely{false};
-  uint64_t Flow{0};
-};
-
-/// A wrapper of binary function with basic blocks and jumps.
-struct FlowFunction {
-  /// Basic blocks in the function.
-  std::vector<FlowBlock> Blocks;
-  /// Jumps between the basic blocks.
-  std::vector<FlowJump> Jumps;
-  /// The index of the entry block.
-  uint64_t Entry{0};
-};
-
-/// Various thresholds and options controlling the behavior of the profile
-/// inference algorithm. Default values are tuned for several large-scale
-/// applications, and can be modified via corresponding command-line flags.
-struct ProfiParams {
-  /// Evenly distribute flow when there are multiple equally likely options.
-  bool EvenFlowDistribution{false};
-
-  /// Evenly re-distribute flow among unknown subgraphs.
-  bool RebalanceUnknown{false};
-
-  /// Join isolated components having positive flow.
-  bool JoinIslands{false};
-
-  /// The cost of increasing a block's count by one.
-  unsigned CostBlockInc{0};
-
-  /// The cost of decreasing a block's count by one.
-  unsigned CostBlockDec{0};
-
-  /// The cost of increasing a count of zero-weight block by one.
-  unsigned CostBlockZeroInc{0};
-
-  /// The cost of increasing the entry block's count by one.
-  unsigned CostBlockEntryInc{0};
-
-  /// The cost of decreasing the entry block's count by one.
-  unsigned CostBlockEntryDec{0};
-
-  /// The cost of increasing an unknown block's count by one.
-  unsigned CostBlockUnknownInc{0};
-
-  /// The cost of increasing a jump's count by one.
-  unsigned CostJumpInc{0};
-
-  /// The cost of increasing a fall-through jump's count by one.
-  unsigned CostJumpFTInc{0};
-
-  /// The cost of decreasing a jump's count by one.
-  unsigned CostJumpDec{0};
-
-  /// The cost of decreasing a fall-through jump's count by one.
-  unsigned CostJumpFTDec{0};
-
-  /// The cost of increasing an unknown jump's count by one.
-  unsigned CostJumpUnknownInc{0};
-
-  /// The cost of increasing an unknown fall-through jump's count by one.
-  unsigned CostJumpUnknownFTInc{0};
-
-  /// The cost of taking an unlikely block/jump.
-  const int64_t CostUnlikely = ((int64_t)1) << 30;
-};
-
-void applyFlowInference(const ProfiParams &Params, FlowFunction &Func);
-void applyFlowInference(FlowFunction &Func);
-
 /// Sample profile inference pass.
 template <typename BT> class SampleProfileInference {
 public:
   using BasicBlockT = typename afdo_detail::TypeMap<BT>::BasicBlockT;
   using FunctionT = typename afdo_detail::TypeMap<BT>::FunctionT;
   using Edge = std::pair<const BasicBlockT *, const BasicBlockT *>;
   using BlockWeightMap = DenseMap<const BasicBlockT *, uint64_t>;
   using EdgeWeightMap = DenseMap<Edge, uint64_t>;

llvm/include/llvm/Transforms/Utils/SampleProfileInferenceBase.h

+//===- Transforms/Utils/SampleProfileInferenceTypes.h ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file provides base types and interfaces for the profile inference
+/// algorithm, profi.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_SAMPLEPROFILEINFERENCEBASE_H
+#define LLVM_TRANSFORMS_UTILS_SAMPLEPROFILEINFERENCEBASE_H
+
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+
+struct FlowJump;
+
+/// A wrapper of a binary basic block.
+struct FlowBlock {
+  uint64_t Index;
+  uint64_t Weight{0};
+  bool HasUnknownWeight{true};
+  bool IsUnlikely{false};
+  uint64_t Flow{0};
+  std::vector<FlowJump *> SuccJumps;
+  std::vector<FlowJump *> PredJumps;
+
+  /// Check if it is the entry block in the function.
+  bool isEntry() const { return PredJumps.empty(); }
+
+  /// Check if it is an exit block in the function.
+  bool isExit() const { return SuccJumps.empty(); }
+};
+
+/// A wrapper of a jump between two basic blocks.
+struct FlowJump {
+  uint64_t Source;
+  uint64_t Target;
+  uint64_t Weight{0};
+  bool HasUnknownWeight{true};
+  bool IsUnlikely{false};
+  uint64_t Flow{0};
+};
+
+/// A wrapper of binary function with basic blocks and jumps.
+struct FlowFunction {
+  /// Basic blocks in the function.
+  std::vector<FlowBlock> Blocks;
+  /// Jumps between the basic blocks.
+  std::vector<FlowJump> Jumps;
+  /// The index of the entry block.
+  uint64_t Entry{0};
+};
+
+/// Various thresholds and options controlling the behavior of the profile
+/// inference algorithm. Default values are tuned for several large-scale
+/// applications, and can be modified via corresponding command-line flags.
+struct ProfiParams {
+  /// Evenly distribute flow when there are multiple equally likely options.
+  bool EvenFlowDistribution{false};
+
+  /// Evenly re-distribute flow among unknown subgraphs.
+  bool RebalanceUnknown{false};
+
+  /// Join isolated components having positive flow.
+  bool JoinIslands{false};
+
+  /// The cost of increasing a block's count by one.
+  unsigned CostBlockInc{0};
+
+  /// The cost of decreasing a block's count by one.
+  unsigned CostBlockDec{0};
+
+  /// The cost of increasing a count of zero-weight block by one.
+  unsigned CostBlockZeroInc{0};
+
+  /// The cost of increasing the entry block's count by one.
+  unsigned CostBlockEntryInc{0};
+
+  /// The cost of decreasing the entry block's count by one.
+  unsigned CostBlockEntryDec{0};
+
+  /// The cost of increasing an unknown block's count by one.
+  unsigned CostBlockUnknownInc{0};
+
+  /// The cost of increasing a jump's count by one.
+  unsigned CostJumpInc{0};
+
+  /// The cost of increasing a fall-through jump's count by one.
+  unsigned CostJumpFTInc{0};
+
+  /// The cost of decreasing a jump's count by one.
+  unsigned CostJumpDec{0};
+
+  /// The cost of decreasing a fall-through jump's count by one.
+  unsigned CostJumpFTDec{0};
+
+  /// The cost of increasing an unknown jump's count by one.
+  unsigned CostJumpUnknownInc{0};
+
+  /// The cost of increasing an unknown fall-through jump's count by one.
+  unsigned CostJumpUnknownFTInc{0};
+
+  /// The cost of taking an unlikely block/jump.
+  const int64_t CostUnlikely = ((int64_t)1) << 30;
+};
+
+void applyFlowInference(const ProfiParams &Params, FlowFunction &Func);
+void applyFlowInference(FlowFunction &Func);
+
+} // namespace llvm
+#endif // LLVM_TRANSFORMS_UTILS_SAMPLEPROFILEINFERENCEBASE_H