[ThinLTO] Only compute imports for current module in FunctionImport pass

teresajohnson · teresajohnson · commit c86af3345c9e · 2016-04-12T21:13:11.000Z
Summary: The function import pass was computing all the imports for all the modules in the index, and only using the imports for the current module. Change this to instead compute only for the given module. This means that the exports list can't be populated, but they weren't being used anyway. Longer term, the linker can collect all the imports and export lists and serialize them out for consumption by the distributed backend processes which use this pass. Reviewers: joker.eph Subscribers: llvm-commits, joker.eph Differential Revision: http://reviews.llvm.org/D18945 llvm-svn: 266125
diff --git a/llvm/include/llvm/IR/ModuleSummaryIndex.h b/llvm/include/llvm/IR/ModuleSummaryIndex.h
@@ -434,6 +434,12 @@ class ModuleSummaryIndex {
   /// but if there was only one module or this was the first module we might
   /// not invoke mergeFrom.
   void removeEmptySummaryEntries();
+
+  /// Collect for the given module the list of function it defines
+  /// (GUID -> Summary).
+  void collectDefinedFunctionsForModule(
+      StringRef ModulePath,
+      std::map<GlobalValue::GUID, FunctionSummary *> &FunctionInfoMap) const;
 };
 
 } // End llvm namespace
diff --git a/llvm/include/llvm/Transforms/IPO/FunctionImport.h b/llvm/include/llvm/Transforms/IPO/FunctionImport.h
@@ -70,6 +70,14 @@ void ComputeCrossModuleImport(
     const ModuleSummaryIndex &Index,
     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
     StringMap<FunctionImporter::ExportSetTy> &ExportLists);
+
+/// Compute all the imports for the given module using the Index.
+///
+/// \p ImportList will be populated with a map that can be passed to
+/// FunctionImporter::importFunctions() above (see description there).
+void ComputeCrossModuleImportForModule(
+    StringRef ModulePath, const ModuleSummaryIndex &Index,
+    FunctionImporter::ImportMapTy &ImportList);
 }
 
 #endif // LLVM_FUNCTIONIMPORT_H
diff --git a/llvm/lib/IR/ModuleSummaryIndex.cpp b/llvm/lib/IR/ModuleSummaryIndex.cpp
@@ -69,6 +69,26 @@ void ModuleSummaryIndex::removeEmptySummaryEntries() {
   }
 }
 
+// Collect for the given module the list of function it defines
+// (GUID -> Summary).
+void ModuleSummaryIndex::collectDefinedFunctionsForModule(
+    StringRef ModulePath,
+    std::map<GlobalValue::GUID, FunctionSummary *> &FunctionInfoMap) const {
+  for (auto &GlobalList : *this) {
+    auto GUID = GlobalList.first;
+    for (auto &GlobInfo : GlobalList.second) {
+      auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobInfo->summary());
+      if (!Summary)
+        // Ignore global variable, focus on functions
+        continue;
+      // Ignore summaries from other modules.
+      if (Summary->modulePath() != ModulePath)
+        continue;
+      FunctionInfoMap[GUID] = Summary;
+    }
+  }
+}
+
 GlobalValueInfo *
 ModuleSummaryIndex::getGlobalValueInfo(uint64_t ValueGUID,
                                        bool PerModuleIndex) const {
diff --git a/llvm/lib/Transforms/IPO/FunctionImport.cpp b/llvm/lib/Transforms/IPO/FunctionImport.cpp
@@ -143,7 +143,7 @@ static void computeImportForFunction(
     const std::map<GlobalValue::GUID, FunctionSummary *> &DefinedFunctions,
     SmallVectorImpl<EdgeInfo> &Worklist,
     FunctionImporter::ImportMapTy &ImportsForModule,
-    StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
+    StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
   for (auto &Edge : Summary.calls()) {
     auto GUID = Edge.first.getGUID();
     DEBUG(dbgs() << " edge -> " << GUID << " Threshold:" << Threshold << "\n");
@@ -176,19 +176,21 @@ static void computeImportForFunction(
 
     // Make exports in the source module.
     auto ExportModulePath = CalleeSummary->modulePath();
-    auto ExportList = ExportLists[ExportModulePath];
-    ExportList.insert(GUID);
-    // Mark all functions and globals referenced by this function as exported to
-    // the outside if they are defined in the same source module.
-    for (auto &Edge : CalleeSummary->calls()) {
-      auto CalleeGUID = Edge.first.getGUID();
-      if (isGlobalExported(Index, ExportModulePath, CalleeGUID))
-        ExportList.insert(CalleeGUID);
-    }
-    for (auto &Ref : CalleeSummary->refs()) {
-      auto GUID = Ref.getGUID();
-      if (isGlobalExported(Index, ExportModulePath, GUID))
-        ExportList.insert(GUID);
+    if (ExportLists) {
+      auto ExportList = (*ExportLists)[ExportModulePath];
+      ExportList.insert(GUID);
+      // Mark all functions and globals referenced by this function as exported
+      // to the outside if they are defined in the same source module.
+      for (auto &Edge : CalleeSummary->calls()) {
+        auto CalleeGUID = Edge.first.getGUID();
+        if (isGlobalExported(Index, ExportModulePath, CalleeGUID))
+          ExportList.insert(CalleeGUID);
+      }
+      for (auto &Ref : CalleeSummary->refs()) {
+        auto GUID = Ref.getGUID();
+        if (isGlobalExported(Index, ExportModulePath, GUID))
+          ExportList.insert(GUID);
+      }
     }
 
     // Insert the newly imported function to the worklist.
@@ -203,7 +205,7 @@ static void ComputeImportForModule(
     const std::map<GlobalValue::GUID, FunctionSummary *> &DefinedFunctions,
     const ModuleSummaryIndex &Index,
     FunctionImporter::ImportMapTy &ImportsForModule,
-    StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
+    StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
   // Worklist contains the list of function imported in this module, for which
   // we will analyse the callees and may import further down the callgraph.
   SmallVector<EdgeInfo, 128> Worklist;
@@ -234,7 +236,7 @@ static void ComputeImportForModule(
 
 } // anonymous namespace
 
-/// Compute all the import and export for every module in the Index.
+/// Compute all the import and export for every module using the Index.
 void llvm::ComputeCrossModuleImport(
     const ModuleSummaryIndex &Index,
     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
@@ -265,7 +267,7 @@ void llvm::ComputeCrossModuleImport(
     DEBUG(dbgs() << "Computing import for Module '" << DefinedFunctions.first()
                  << "'\n");
     ComputeImportForModule(DefinedFunctions.second, Index, ImportsForModule,
-                           ExportLists);
+                           &ExportLists);
   }
 
 #ifndef NDEBUG
@@ -286,6 +288,31 @@ void llvm::ComputeCrossModuleImport(
 #endif
 }
 
+/// Compute all the imports for the given module in the Index.
+void llvm::ComputeCrossModuleImportForModule(
+    StringRef ModulePath, const ModuleSummaryIndex &Index,
+    FunctionImporter::ImportMapTy &ImportList) {
+
+  // Collect the list of functions this module defines.
+  // GUID -> Summary
+  std::map<GlobalValue::GUID, FunctionSummary *> FunctionInfoMap;
+  Index.collectDefinedFunctionsForModule(ModulePath, FunctionInfoMap);
+
+  // Compute the import list for this module.
+  DEBUG(dbgs() << "Computing import for Module '" << ModulePath << "'\n");
+  ComputeImportForModule(FunctionInfoMap, Index, ImportList);
+
+#ifndef NDEBUG
+  DEBUG(dbgs() << "* Module " << ModulePath << " imports from "
+               << ImportList.size() << " modules.\n");
+  for (auto &Src : ImportList) {
+    auto SrcModName = Src.first();
+    DEBUG(dbgs() << " - " << Src.second.size() << " functions imported from "
+                 << SrcModName << "\n");
+  }
+#endif
+}
+
 // Automatically import functions in Module \p DestModule based on the summaries
 // index.
 //
@@ -463,13 +490,10 @@ class FunctionImportPass : public ModulePass {
       Index = IndexPtr.get();
     }
 
-    // First step is collecting the import/export lists
-    // The export list is not used yet, but could limit the amount of renaming
-    // performed in renameModuleForThinLTO()
-    StringMap<FunctionImporter::ImportMapTy> ImportLists;
-    StringMap<FunctionImporter::ExportSetTy> ExportLists;
-    ComputeCrossModuleImport(*Index, ImportLists, ExportLists);
-    auto &ImportList = ImportLists[M.getModuleIdentifier()];
+    // First step is collecting the import list.
+    FunctionImporter::ImportMapTy ImportList;
+    ComputeCrossModuleImportForModule(M.getModuleIdentifier(), *Index,
+                                      ImportList);
 
     // Next we need to promote to global scope and rename any local values that
     // are potentially exported to other modules.
