[Prototype] Print dominant instruction size

Author: kateinoigakukun

include/swift/Serialization/ModuleSummary.h

@@ -99,6 +99,8 @@ class FunctionSummary {
   TypeRefListTy TypeRefList;
   /// The symbol name of the function only for debug and test purposes.
   std::string Name;
+  /// Size of instructions only for debug purpose
+  size_t InstSize;
 
 public:
   FunctionSummary() = default;
@@ -126,6 +128,9 @@ class FunctionSummary {
   void setName(std::string name) { this->Name = name; }
 
   GUID getGUID() const { return Guid; }
+
+  size_t getInstSize() const { return InstSize; }
+  void setInstSize(size_t size) { this->InstSize = size; }
 };
 
 /// A slot in a set of virtual tables.

lib/Serialization/ModuleSummaryFormat.cpp

@@ -122,7 +122,7 @@ void Serializer::emitFunctionSummary(const FunctionSummary *summary) {
   FunctionMetadataLayout::emitRecord(
       Out, ScratchRecord, AbbrCodes[FunctionMetadataLayout::Code],
       summary->getGUID(), unsigned(summary->isLive()),
-      unsigned(summary->isPreserved()), debugFuncName);
+      unsigned(summary->isPreserved()), summary->getInstSize(), debugFuncName);
 
   for (auto call : summary->calls()) {
     std::string debugName = ModuleSummaryEmbedDebugName ? call.getName() : "";
@@ -361,8 +361,10 @@ bool Deserializer::readModuleSummary() {
       std::string name;
       unsigned isLive, isPreserved;
       bool shouldMerge = false;
+      uint32_t instSize;
 
-      FunctionMetadataLayout::readRecord(Scratch, guid, isLive, isPreserved);
+      FunctionMetadataLayout::readRecord(Scratch, guid, isLive, isPreserved,
+                                         instSize);
       name = BlobData.str();
       if (auto summary = moduleSummary.getFunctionSummary(guid)) {
         CurrentFunc = summary;
@@ -382,6 +384,7 @@ bool Deserializer::readModuleSummary() {
       if (!shouldMerge || !name.empty()) {
         CurrentFunc->setName(name);
       }
+      CurrentFunc->setInstSize(instSize);
       break;
     }
     case CALL_GRAPH_EDGE: {

lib/Serialization/ModuleSummaryFormat.h

@@ -23,6 +23,7 @@ namespace modulesummary {
 using llvm::BCBlob;
 using llvm::BCFixed;
 using llvm::BCRecordLayout;
+using llvm::BCVBR;
 
 const unsigned char MODULE_SUMMARY_SIGNATURE[] = {'M', 'O', 'D', 'S'};
 const unsigned RECORD_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID;
@@ -48,6 +49,7 @@ using FunctionMetadataLayout = BCRecordLayout<FUNC_METADATA,
                                               BCGUID,     // function guid
                                               BCFixed<1>, // live
                                               BCFixed<1>, // preserved
+                                              BCVBR<16>,  // instruction size
                                               BCBlob // name (debug purpose)
                                               >;
 using CallGraphEdgeLayout =

lib/Serialization/ModuleSummaryIndexer.cpp

@@ -320,14 +320,17 @@ bool shouldPreserveFunction(const SILFunction &F) {
 
 void FunctionSummaryIndexer::indexFunction() {
   GUID guid = getGUIDFromUniqueName(F.getName());
+  size_t instSize = 0;
   TheSummary = std::make_unique<FunctionSummary>(guid);
   TheSummary->setName(F.getName());
   for (auto &BB : F) {
     for (auto &I : BB) {
       visit(&I);
+      instSize++;
     }
   }
   TheSummary->setPreserved(shouldPreserveFunction(F));
+  TheSummary->setInstSize(instSize);
 }
 
 class ModuleSummaryIndexer {
@@ -447,7 +450,6 @@ void ModuleSummaryIndexer::indexModule() {
     FunctionSummaryIndexer indexer(F);
     indexer.indexFunction();
     std::unique_ptr<FunctionSummary> FS = indexer.takeSummary();
-    FS->setPreserved(shouldPreserveFunction(F));
     TheSummary->addFunctionSummary(std::move(FS));
   }
 

tools/swift-module-summary-test/swift-module-summary-test.cpp

@@ -207,6 +207,10 @@ struct CallGraph {
 
     CallGraph *getParent() const { return Parent; }
 
+    FunctionSummary *getFS() const {
+      return Parent->Summary.getFunctionSummary(Guid);
+    }
+
     void printAsOperand(raw_ostream &OS, bool /*PrintType*/) {
       FunctionSummary *FS = Parent->Summary.getFunctionSummary(Guid);
       if (!FS) {
@@ -410,9 +414,55 @@ class DomCallTree : public DomCallTreeBase {
   DomCallTree(CallGraph &CG) : DominatorTreeBase() { recalculate(CG); }
 };
 
+class RetainedSizeCalculator {
+  struct Entry {
+    DomCallInfoNode *DomNode;
+    size_t InstSize;
+  };
+  std::map<DomCallInfoNode *, size_t> SizeCache;
+  std::vector<Entry> Entries;
+
+  size_t getInstSize(DomCallInfoNode *domNode) {
+    auto FS = domNode->getBlock()->getFS();
+    size_t size = FS->getInstSize();
+    for (auto I = domNode->begin(), E = domNode->end(); I != E; ++I) {
+      auto Child = *I;
+      size += getInstSize(Child);
+    }
+    SizeCache[domNode] = size;
+    return size;
+  }
+
+  void calculateRecursively(DomCallInfoNode *domNode) {
+    Entries.push_back({domNode, getInstSize(domNode)});
+    for (auto child : domNode->getChildren()) {
+      calculateRecursively(child);
+    }
+  }
+
+public:
+  void calculate(DomCallInfoNode *root) {
+    for (auto child : root->getChildren()) {
+      calculateRecursively(child);
+    }
+    std::sort(Entries.begin(), Entries.end(),
+              [](Entry lhs, Entry rhs) { return lhs.InstSize > rhs.InstSize; });
+  }
+
+  void display(llvm::raw_ostream &O) {
+    for (auto entry : Entries) {
+      auto FS = entry.DomNode->getBlock()->getFS();
+      O << entry.InstSize << "\t| " << FS->getName() << "\n";
+    }
+  }
+};
+
 int dominance_analysis(CallGraph &CG) {
   DomCallTree DT(CG);
-  DT.print(llvm::dbgs());
+  DomCallInfoNode *Root = DT.getRootNode();
+  RetainedSizeCalculator calculator;
+  calculator.calculate(Root);
+  calculator.display(llvm::dbgs());
   return 0;
 };
 
@@ -487,7 +537,15 @@ int main(int argc, char *argv[]) {
     modulesummary::loadModuleSummaryIndex(fileBufOrErr.get()->getMemBufferRef(),
                                           summary);
     CallGraph CG(std::move(summary));
-    return dominance_analysis(CG);
+    DomCallTree DT(CG);
+    DomCallInfoNode *Root = DT.getRootNode();
+    RetainedSizeCalculator calculator;
+    calculator.calculate(Root);
+    withOutputFile(diags, options::OutputFilename, [&](raw_ostream &out) {
+      calculator.display(out);
+      return false;
+    });
+    break;
   }
   }
   return 0;