Modify block-size option

Created using spr 1.3.4

Author: aaupov

bolt/docs/Heatmaps.md

@@ -89,13 +89,12 @@ For the generation, the default bucket size was used with a line size of 128.
 Some useful options are:
 
 ```
--block-size=<uint>  - heatmap bucket size in bytes (default 64)
 -line-size=<uint>   - number of entries per line (default 256).
                       Use 128 if the heatmap doesn't fit screen horizontally.
+-block-size=<uint>[:<pow2>,...]  - heatmap bucket size in bytes (default 64),
+                      optionally followed by power-of-two zoom-out scales to
+                      produce coarse grained heatmaps (default 6, 2, 6 =>
+                      4K, 16K, 1MB).
 -max-address=<uint> - maximum address considered valid for heatmap (default 4GB)
 -print-mappings     - print mappings in the legend, between characters/blocks and text sections (default false)
--heatmap-zoom-out=<uint>,... - print zoomed out heatmaps with given block sizes,
-                      must be multiples of block-size in ascending order.
-                      Suggested values: 4096 (default page size), 16384 (16k page),
-                      1048576 (1MB for XL workloads).
 ```

bolt/include/bolt/Profile/Heatmap.h

@@ -86,8 +86,9 @@ class Heatmap {
 
   size_t size() const { return Map.size(); }
 
-  /// Increase bucket size to \p TargetSize, recomputing the heatmap.
-  bool resizeBucket(uint64_t TargetSize);
+  /// Increase bucket size by 2^\p Scale, recomputing the heatmap.
+  /// Returns new bucket size.
+  uint64_t resizeBucket(uint64_t Pow2Scale);
 };
 
 } // namespace bolt

bolt/include/bolt/Utils/CommandLineOpts.h

@@ -23,6 +23,19 @@ enum HeatmapModeKind {
   HM_Optional   // perf2bolt --heatmap
 };
 
+struct HeatmapBlockSpec {
+  unsigned Initial{0}; // Initial block size in bytes.
+  llvm::SmallVector<unsigned> Scales; // Pow2 zoom factors applied cumulatively.
+};
+
+struct HeatmapBlockSpecParser : public llvm::cl::parser<HeatmapBlockSpec> {
+  explicit HeatmapBlockSpecParser(llvm::cl::Option &O)
+      : llvm::cl::parser<HeatmapBlockSpec>(O) {}
+  // Return true on error.
+  bool parse(llvm::cl::Option &O, llvm::StringRef ArgName, llvm::StringRef Arg,
+             HeatmapBlockSpec &Val);
+};
+
 extern HeatmapModeKind HeatmapMode;
 extern bool BinaryAnalysisMode;
 
@@ -47,7 +60,8 @@ extern llvm::cl::opt<bool> EqualizeBBCounts;
 extern llvm::cl::opt<bool> ForcePatch;
 extern llvm::cl::opt<bool> RemoveSymtab;
 extern llvm::cl::opt<unsigned> ExecutionCountThreshold;
-extern llvm::cl::opt<unsigned> HeatmapBlock;
+extern llvm::cl::opt<HeatmapBlockSpec, false, HeatmapBlockSpecParser>
+    HeatmapBlock;
 extern llvm::cl::opt<unsigned long long> HeatmapMaxAddress;
 extern llvm::cl::opt<unsigned long long> HeatmapMinAddress;
 extern llvm::cl::opt<bool> HeatmapPrintMappings;

bolt/lib/Core/BinaryFunction.cpp

@@ -3326,7 +3326,7 @@ void BinaryFunction::duplicateConstantIslands() {
 static std::string constructFilename(std::string Filename,
                                      std::string Annotation,
                                      std::string Suffix) {
-  std::replace(Filename.begin(), Filename.end(), '/', '-');
+  llvm::replace(Filename, '/', '-');
   if (!Annotation.empty())
     Annotation.insert(0, "-");
   if (Filename.size() + Annotation.size() + Suffix.size() > MAX_PATH) {

bolt/lib/Core/DIEBuilder.cpp

@@ -437,10 +437,10 @@ getUnitForOffset(DIEBuilder &Builder, DWARFContext &DWCtx,
       // This is a work around for XCode clang. There is a build error when we
       // pass DWCtx.compile_units() to llvm::upper_bound
       std::call_once(InitVectorFlag, initCUVector);
-      auto CUIter = std::upper_bound(CUOffsets.begin(), CUOffsets.end(), Offset,
-                                     [](uint64_t LHS, const DWARFUnit *RHS) {
-                                       return LHS < RHS->getNextUnitOffset();
-                                     });
+      auto CUIter = llvm::upper_bound(CUOffsets, Offset,
+                                      [](uint64_t LHS, const DWARFUnit *RHS) {
+                                        return LHS < RHS->getNextUnitOffset();
+                                      });
       CU = CUIter != CUOffsets.end() ? (*CUIter) : nullptr;
     }
     return CU;

bolt/lib/Passes/AsmDump.cpp

@@ -109,7 +109,7 @@ void dumpFunction(const BinaryFunction &BF) {
   }
 
   std::string PrintName = BF.getPrintName();
-  std::replace(PrintName.begin(), PrintName.end(), '/', '-');
+  llvm::replace(PrintName, '/', '-');
   std::string Filename =
       opts::AsmDump.empty()
           ? (PrintName + ".s")

bolt/lib/Passes/BinaryPasses.cpp

@@ -35,7 +35,7 @@ static const char *dynoStatsOptName(const bolt::DynoStats::Category C) {
 
   OptNames[C] = bolt::DynoStats::Description(C);
 
-  std::replace(OptNames[C].begin(), OptNames[C].end(), ' ', '-');
+  llvm::replace(OptNames[C], ' ', '-');
 
   return OptNames[C].c_str();
 }

bolt/lib/Profile/DataAggregator.cpp

@@ -68,12 +68,6 @@ FilterPID("pid",
   cl::Optional,
   cl::cat(AggregatorCategory));
 
-static cl::list<uint64_t>
-    HeatmapZoomOut("heatmap-zoom-out", cl::CommaSeparated,
-                   cl::desc("print secondary heatmaps with given bucket sizes"),
-                   cl::value_desc("bucket_size"), cl::Optional,
-                   cl::cat(HeatmapCategory));
-
 static cl::opt<bool>
 IgnoreBuildID("ignore-build-id",
   cl::desc("continue even if build-ids in input binary and perf.data mismatch"),
@@ -1320,8 +1314,9 @@ std::error_code DataAggregator::printLBRHeatMap() {
     opts::HeatmapMaxAddress = 0xffffffffffffffff;
     opts::HeatmapMinAddress = KernelBaseAddr;
   }
-  Heatmap HM(opts::HeatmapBlock, opts::HeatmapMinAddress,
-             opts::HeatmapMaxAddress, getTextSections(BC));
+  opts::HeatmapBlockSpec HMBS = opts::HeatmapBlock;
+  Heatmap HM(HMBS.Initial, opts::HeatmapMinAddress, opts::HeatmapMaxAddress,
+             getTextSections(BC));
   auto getSymbolValue = [&](const MCSymbol *Symbol) -> uint64_t {
     if (Symbol)
       if (ErrorOr<uint64_t> SymValue = BC->getSymbolValue(*Symbol))
@@ -1371,10 +1366,9 @@ std::error_code DataAggregator::printLBRHeatMap() {
     HM.printCDF(opts::HeatmapOutput + ".csv");
     HM.printSectionHotness(opts::HeatmapOutput + "-section-hotness.csv");
   }
-  // Provide coarse-grained heatmap if requested via --heatmap-zoom-out
-  for (const uint64_t NewBucketSize : opts::HeatmapZoomOut) {
-    if (!HM.resizeBucket(NewBucketSize))
-      break;
+  // Provide coarse-grained heatmaps if requested via zoom-out scales
+  for (const uint64_t NewBucketSizeScale : HMBS.Scales) {
+    uint64_t NewBucketSize = HM.resizeBucket(NewBucketSizeScale);
     if (opts::HeatmapOutput == "-")
       HM.print(opts::HeatmapOutput);
     else

bolt/lib/Profile/Heatmap.cpp

@@ -55,6 +55,8 @@ void Heatmap::print(StringRef FileName) const {
     errs() << "error opening output file: " << EC.message() << '\n';
     exit(1);
   }
+  outs() << "HEATMAP: dumping heatmap with bucket size " << BucketSize << " to "
+         << FileName << '\n';
   print(OS);
 }
 
@@ -365,17 +367,12 @@ void Heatmap::printSectionHotness(raw_ostream &OS) const {
                   100.0 * UnmappedHotness / NumTotalCounts);
 }
 
-bool Heatmap::resizeBucket(uint64_t TargetSize) {
-  if (TargetSize <= BucketSize)
-    return false;
+uint64_t Heatmap::resizeBucket(uint64_t Pow2Scale) {
   std::map<uint64_t, uint64_t> NewMap;
-  for (const auto [Bucket, Count] : Map) {
-    const uint64_t Address = Bucket * BucketSize;
-    NewMap[Address / TargetSize] += Count;
-  }
+  for (const auto [Bucket, Count] : Map)
+    NewMap[Bucket >> Pow2Scale] += Count;
   Map = NewMap;
-  BucketSize = TargetSize;
-  return true;
+  return BucketSize <<= Pow2Scale;
 }
 } // namespace bolt
 } // namespace llvm

bolt/lib/Utils/CommandLineOpts.cpp

@@ -103,10 +103,38 @@ ExecutionCountThreshold("execution-count-threshold",
   cl::Hidden,
   cl::cat(BoltOptCategory));
 
-cl::opt<unsigned>
-    HeatmapBlock("block-size",
-                 cl::desc("size of a heat map block in bytes (default 64)"),
-                 cl::init(64), cl::cat(HeatmapCategory));
+bool HeatmapBlockSpecParser::parse(cl::Option &O, StringRef ArgName,
+                                   StringRef Arg, HeatmapBlockSpec &Val) {
+  auto [InitialPart, ScalesPart] = Arg.split(':');
+  if (InitialPart.getAsInteger(10, Val.Initial)) {
+    O.error("'" + Arg +
+            "' value invalid for block-size initial_size argument");
+    return true;
+  }
+  // Scales part is optional.
+  if (ScalesPart.empty())
+    return false;
+  SmallVector<StringRef> Scales;
+  ScalesPart.split(Scales, ',');
+  for (StringRef Scale : Scales) {
+    unsigned &ScaleVal = Val.Scales.emplace_back(0);
+    if (Scale.getAsInteger(10, ScaleVal)) {
+      O.error("'" + Scale + "' value invalid for block-size scale argument");
+      return true;
+    }
+  }
+  return false;
+}
+
+cl::opt<opts::HeatmapBlockSpec, false, opts::HeatmapBlockSpecParser>
+    HeatmapBlock(
+        "block-size", cl::value_desc("initial_size{:pow2_scale1,...}"),
+        cl::desc("size of a heat map block in bytes (default 64), optionally "
+                 "followed by a comma-separated list of cumulative scales "
+                 "represented as powers of 2 to produce zoomed-out heatmaps "
+                 "(default 6, 2, 6 = 4k, 16k, 1M block sizes)."),
+        cl::init(HeatmapBlockSpec{/*Initial*/ 64, /*Scales*/ {6, 2, 6}}),
+        cl::cat(HeatmapCategory));
 
 cl::opt<unsigned long long> HeatmapMaxAddress(
     "max-address", cl::init(0xffffffff),