[MemProf] Add printing utilities for MemProf summary structures

[tejohnson]

Summary

Split out of D140908 as suggested, and added unit testing.

[snehasish]

lgtm with some minor comments.

llvm/unittests/IR/ModuleSummaryIndexTest.cpp

19

nit: Unless you have state shared across multiple tests, it would be simpler to avoid the test fixture and keep makeLLVMIndex as static helper method.

34

Can we remove content in the string summary which is unrelated to the test? E.g. funcFlags should be ok to drop?

53

Can we use a raw string for the expectation?

[tejohnson]

Address comments

llvm/include/llvm/IR/ModuleSummaryIndex.h

struct CallsiteInfo {
   CallsiteInfo(ValueInfo Callee, SmallVector<unsigned> StackIdIndices)
       : Callee(Callee), StackIdIndices(std::move(StackIdIndices)) {}
   CallsiteInfo(ValueInfo Callee, SmallVector<unsigned> Clones,
                SmallVector<unsigned> StackIdIndices)
       : Callee(Callee), Clones(std::move(Clones)),
         StackIdIndices(std::move(StackIdIndices)) {}
 };
 
+inline raw_ostream &operator<<(raw_ostream &OS, const CallsiteInfo &SNI) {
+  OS << "Callee: " << SNI.Callee;
+  bool First = true;
+  OS << " Clones: ";
+  for (auto V : SNI.Clones) {
+    if (!First)
+      OS << ", ";
+    First = false;
+    OS << V;
+  }
+  First = true;
+  OS << " StackIds: ";
+  for (auto Id : SNI.StackIdIndices) {
+    if (!First)
+      OS << ", ";
+    First = false;
+    OS << Id;
+  }
+  return OS;
+}
+
 // Allocation type assigned to an allocation reached by a given context.
 // More can be added but initially this is just noncold and cold.
 // Values should be powers of two so that they can be ORed, in particular to
 // track allocations that have different behavior with different calling
 // contexts.
 enum class AllocationType : uint8_t { None = 0, NotCold = 1, Cold = 2 };
 
 /// Summary of a single MIB in a memprof metadata on allocations.
 struct MIBInfo {
   // The allocation type for this profiled context.
   AllocationType AllocType;
 
   // Represents stack ids in this context, recorded as indices into the
   // StackIds vector in the summary index, which in turn holds the full 64-bit
   // stack ids. This reduces memory as there are in practice far fewer unique
   // stack ids than stack id references.
   SmallVector<unsigned> StackIdIndices;
 
   MIBInfo(AllocationType AllocType, SmallVector<unsigned> StackIdIndices)
       : AllocType(AllocType), StackIdIndices(std::move(StackIdIndices)) {}
 };
 
+inline raw_ostream &operator<<(raw_ostream &OS, const MIBInfo &MIB) {
+  OS << "AllocType " << (unsigned)MIB.AllocType;
+  bool First = true;
+  OS << " StackIds: ";
+  for (auto Id : MIB.StackIdIndices) {
+    if (!First)
+      OS << ", ";
+    First = false;
+    OS << Id;
+  }
+  return OS;
+}
+
 /// Summary of memprof metadata on allocations.
 struct AllocInfo {
   // Used to record whole program analysis cloning decisions.
   // The ThinLTO backend will need to create as many clones as there are entries
   // in the vector (it is expected and should be confirmed that all such
   // summaries in the same FunctionSummary have the same number of entries).
   // Each index records version info for the corresponding clone of this
   // function. The value is the allocation type of the corresponding allocation.
   // Index 0 is the original version. Before cloning, index 0 may have more than
   // one allocation type.
   SmallVector<uint8_t> Versions;
 
   // Vector of MIBs in this memprof metadata.
   std::vector<MIBInfo> MIBs;
 
   AllocInfo(std::vector<MIBInfo> MIBs) : MIBs(std::move(MIBs)) {
     Versions.push_back(0);
   }
   AllocInfo(SmallVector<uint8_t> Versions, std::vector<MIBInfo> MIBs)
       : Versions(std::move(Versions)), MIBs(std::move(MIBs)) {}
 };
 
+inline raw_ostream &operator<<(raw_ostream &OS, const AllocInfo &AE) {
+  bool First = true;
+  OS << "Versions: ";
+  for (auto V : AE.Versions) {
+    if (!First)
+      OS << ", ";
+    First = false;
+    OS << (unsigned)V;
+  }
+  OS << " MIB:\n";
+  for (auto &M : AE.MIBs) {
+    OS << "\t\t" << M << "\n";
+  }
+  return OS;
+}
+
 /// Function and variable summary information to aid decisions and
 /// implementation of importing.
 class GlobalValueSummary {
 public:
   /// Sububclass discriminator (for dyn_cast<> et al.)
   enum SummaryKind : unsigned { AliasKind, FunctionKind, GlobalVarKind };
 
   /// Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.

llvm/unittests/IR/CMakeLists.txt

add_llvm_unittest(IRTests
   IRBuilderTest.cpp
   InstructionsTest.cpp
   IntrinsicsTest.cpp
   LegacyPassManagerTest.cpp
   MDBuilderTest.cpp
   ManglerTest.cpp
   MetadataTest.cpp
   ModuleTest.cpp
+  ModuleSummaryIndexTest.cpp
   PassManagerTest.cpp
   PatternMatch.cpp
   ShuffleVectorInstTest.cpp
   TimePassesTest.cpp
   TypesTest.cpp
   UseTest.cpp
   UserTest.cpp
   ValueHandleTest.cpp

llvm/unittests/IR/ModuleSummaryIndexTest.cpp

+//===- ModuleSummaryIndexTest.cpp - ModuleSummaryIndex Unit Tests-============//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/ModuleSummaryIndex.h"
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/Support/SourceMgr.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+static std::unique_ptr<ModuleSummaryIndex> makeLLVMIndex(const char *Summary) {
+  SMDiagnostic Err;
+  std::unique_ptr<ModuleSummaryIndex> Index =
+      parseSummaryIndexAssemblyString(Summary, Err);
+  if (!Index)
+    Err.print("ModuleSummaryIndexTest", errs());
+  return Index;
+}
+
+TEST(ModuleSummaryIndexTest, MemProfSummaryPrinting) {
+  std::unique_ptr<ModuleSummaryIndex> Index = makeLLVMIndex(R"Summary(
+^0 = module: (path: "test.o", hash: (0, 0, 0, 0, 0))
+^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external), insts: 2, allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (1, 2, 3, 4)), (type: cold, stackIds: (1, 2, 3, 5))))))))
+^2 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external), insts: 22, calls: ((callee: ^1)), callsites: ((callee: ^1, clones: (0), stackIds: (3, 4)), (callee: ^1, clones: (0), stackIds: (3, 5))))))
+)Summary");
+
+  std::string Data;
+  raw_string_ostream OS(Data);
+
+  ASSERT_NE(Index, nullptr);
+  auto *CallsiteSummary =
+      cast<FunctionSummary>(Index->getGlobalValueSummary(/*guid=*/25));
+  for (auto &CI : CallsiteSummary->callsites())
+    OS << "\n" << CI;
+
+  auto *AllocSummary =
+      cast<FunctionSummary>(Index->getGlobalValueSummary(/*guid=*/23));
+  for (auto &AI : AllocSummary->allocs())
+    OS << "\n" << AI;
+
+  OS.flush();
+  EXPECT_EQ(Data, R"(
+Callee: 23 Clones: 0 StackIds: 2, 3
+Callee: 23 Clones: 0 StackIds: 2, 4
+Versions: 0 MIB:
+    AllocType 1 StackIds: 0, 1, 2, 3
+    AllocType 2 StackIds: 0, 1, 2, 4
+)");
+}
+} // end anonymous namespace