[clang][clang-scan-deps] Add a mode that can compute overhead in duplicated module builds

[dang]

Summary

Adds a command line option "--metrics" that computes and outputs this
information at the end of a run.
This identifies modules duplicated due to strict context hashing and computes
how many of them of identical ASTs.

[dang]

Updating D80003: [clang][clang-scan-deps] Add a mode that can compute overhead in duplicated module builds (Patch series 3/3)

[dang]

Rebase this on top of the new AST Signature patch

clang/include/clang/Frontend/CompilerInvocation.h

public:
   static void setLangDefaults(LangOptions &Opts, InputKind IK,
                    const llvm::Triple &T, PreprocessorOptions &PPOpts,
                    LangStandard::Kind LangStd = LangStandard::lang_unspecified);
 
   /// Retrieve a module hash string that is suitable for uniquely
   /// identifying the conditions under which the module was built.
   std::string getModuleHash() const;
 
+  std::string getModuleHash(DiagnosticsEngine &Diags,
+                            bool UseStrictContextHash) const;
+
   /// @}
   /// @name Option Subgroups
   /// @{
 
   AnalyzerOptionsRef getAnalyzerOpts() const { return AnalyzerOpts; }
 
   MigratorOptions &getMigratorOpts() { return MigratorOpts; }
   const MigratorOptions &getMigratorOpts() const { return MigratorOpts; }

clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h

 //===- ModuleDepCollector.h - Callbacks to collect deps ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_DEPENDENCY_SCANNING_MODULE_DEP_COLLECTOR_H
 #define LLVM_CLANG_TOOLING_DEPENDENCY_SCANNING_MODULE_DEP_COLLECTOR_H
 
 #include "clang/Basic/LLVM.h"
+#include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Serialization/ASTReader.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/raw_ostream.h"
struct ModuleDeps {
   /// The context hash of a module represents the set of compiler options that
   /// may make one version of a module incompatible with another. This includes
   /// things like language mode, predefined macros, header search paths, etc...
   ///
   /// Modules with the same name but a different \c ContextHash should be
   /// treated as separate modules for the purpose of a build.
   std::string ContextHash;
 
+  /// The relaxed context hash of a module represents the \c ContextHash that
+  /// would have been used with strict context hashing disabled. This is only
+  /// used kept track off in order to compute module aliasing efficency of
+  /// strict context hashing w.r.t relaxed context hashing.
+  std::string RelaxedContextHash;
+
+  // This is the hash of the AST represented by the module. This is only used to
+  // keep track of module aliasing efficiency.
+  ASTFileSignature ModuleSignature;
+
   /// The path to the modulemap file which defines this module.
   ///
   /// This can be used to explicitly build this module. This file will
   /// additionally appear in \c FileDeps as a dependency.
   std::string ClangModuleMapFile;
 
   /// The path to where an implicit build would put the PCM for this module.
   std::string ImplicitModulePCMPath;

 
 private:
   friend ModuleDepCollectorPP;
 
   CompilerInstance &Instance;
   DependencyConsumer &Consumer;
   std::string MainFile;
   std::string ContextHash;
+  std::string RelaxedContextHash;
   std::vector<std::string> MainDeps;
   std::unordered_map<std::string, ModuleDeps> Deps;
   std::unique_ptr<DependencyOutputOptions> Opts;
 };
 
 } // end namespace dependencies
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_DEPENDENCY_SCANNING_MODULE_DEP_COLLECTOR_H

clang/lib/Frontend/CompilerInvocation.cpp

bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
   if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
       !Res.getLangOpts()->Sanitize.empty()) {
     Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
     Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
   }
   return Success;
 }
 
-std::string CompilerInvocation::getModuleHash() const {
+std::string CompilerInvocation::getModuleHash(DiagnosticsEngine &Diags) const {
+  return getModuleHash(Diags, getHeaderSearchOpts().ModulesStrictContextHash);
+}
+
+std::string CompilerInvocation::getModuleHash(DiagnosticsEngine &Diags,
+                                              bool UseStrictContextHash) const {
   // Note: For QoI reasons, the things we use as a hash here should all be
   // dumped via the -module-info flag.
   using llvm::hash_code;
   using llvm::hash_value;
   using llvm::hash_combine;
   using llvm::hash_combine_range;
 
   // Start the signature with the compiler version.
code = hash_combine(code, hsOpts.Sysroot,
                       hsOpts.UseDebugInfo,
                       hsOpts.UseBuiltinIncludes,
                       hsOpts.UseStandardSystemIncludes,
                       hsOpts.UseStandardCXXIncludes,
                       hsOpts.UseLibcxx,
                       hsOpts.ModulesValidateDiagnosticOptions);
   code = hash_combine(code, hsOpts.ResourceDir);
 
-  if (hsOpts.ModulesStrictContextHash) {
+  if (UseStrictContextHash) {
     hash_code SHPC = hash_combine_range(hsOpts.SystemHeaderPrefixes.begin(),
                                         hsOpts.SystemHeaderPrefixes.end());
     hash_code UEC = hash_combine_range(hsOpts.UserEntries.begin(),
                                        hsOpts.UserEntries.end());
     code = hash_combine(code, hsOpts.SystemHeaderPrefixes.size(), SHPC,
                         hsOpts.UserEntries.size(), UEC);
 
     const DiagnosticOptions &diagOpts = getDiagnosticOpts();

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

 }
 
 void ModuleDepCollectorPP::FileChanged(SourceLocation Loc,
                                        FileChangeReason Reason,
                                        SrcMgr::CharacteristicKind FileType,
                                        FileID PrevFID) {
   if (Reason != PPCallbacks::EnterFile)
     return;
-  
   // This has to be delayed as the context hash can change at the start of
   // `CompilerInstance::ExecuteAction`.
   if (MDC.ContextHash.empty()) {
-    MDC.ContextHash = Instance.getInvocation().getModuleHash();
+    MDC.ContextHash =
+        Instance.getInvocation().getModuleHash(Instance.getDiagnostics());
+    MDC.RelaxedContextHash = Instance.getInvocation().getModuleHash(
+        Instance.getDiagnostics(), /* UseStrictContextHash */ false);
     MDC.Consumer.handleContextHash(MDC.ContextHash);
   }
 
   SourceManager &SM = Instance.getSourceManager();
 
   // Dependency generation really does want to go all the way to the
   // file entry for a source location to find out what is depended on.
   // We do not want #line markers to affect dependency generation!
const FileEntry *ModuleMap = Instance.getPreprocessor()
                                    .getHeaderSearchInfo()
                                    .getModuleMap()
                                    .getContainingModuleMapFile(M);
 
   MD.ClangModuleMapFile = std::string(ModuleMap ? ModuleMap->getName() : "");
   MD.ModuleName = M->getFullModuleName();
   MD.ImplicitModulePCMPath = std::string(M->getASTFile()->getName());
   MD.ContextHash = MDC.ContextHash;
+  MD.RelaxedContextHash = MDC.RelaxedContextHash;
   serialization::ModuleFile *MF =
       MDC.Instance.getASTReader()->getModuleManager().lookup(M->getASTFile());
+  MD.ModuleSignature = MF->ASTSignature;
   MDC.Instance.getASTReader()->visitInputFiles(
       *MF, true, true, [&](const serialization::InputFile &IF, bool isSystem) {
         MD.FileDeps.insert(IF.getFile()->getName());
       });
 
   llvm::DenseSet<const Module *> AddedModules;
   addAllSubmoduleDeps(M, MD, AddedModules);
 }

clang/tools/clang-scan-deps/ClangScanDeps.cpp

 //===- ClangScanDeps.cpp - Implementation of clang-scan-deps --------------===//
 //
 // 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 "clang/Basic/Module.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningTool.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningWorker.h"
 #include "clang/Tooling/JSONCompilationDatabase.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
+#include "llvm/Support/raw_ostream.h"
 #include <mutex>
 #include <thread>
 
 using namespace clang;
 using namespace tooling::dependencies;
 
 namespace {
 
llvm::cl::desc(
         "until reaching the end directive."),
     llvm::cl::init(true), llvm::cl::cat(DependencyScannerCategory));
 
 llvm::cl::opt<bool> Verbose("v", llvm::cl::Optional,
                             llvm::cl::desc("Use verbose output."),
                             llvm::cl::init(false),
                             llvm::cl::cat(DependencyScannerCategory));
 
+llvm::cl::opt<bool> GatherMetrics(
+    "metrics", llvm::cl::Optional,
+    llvm::cl::desc(
+        "Gather metrics during tool operation to measure overhead of modules "
+        "built in explicit mode with respect to implicit modules."),
+    llvm::cl::init(false), llvm::cl::cat(DependencyScannerCategory));
+
 } // end anonymous namespace
 
 /// \returns object-file path derived from source-file path.
 static std::string getObjFilePath(StringRef SrcFile) {
   SmallString<128> ObjFileName(SrcFile);
   llvm::sys::path::replace_extension(ObjFileName, "o");
   return std::string(ObjFileName.str());
 }
void printFullOutput(raw_ostream &OS) {
     Object Output{
         {"modules", std::move(OutModules)},
         {"translation-units", std::move(TUs)},
     };
 
     OS << llvm::formatv("{0:2}\n", Value(std::move(Output)));
   }
 
+  void computeAndPrintBuildMetrics(raw_ostream &OS) {
+    std::unordered_map<std::string, BuiltModulesEfficiencyInfo>
+        RelaxedHashesEfficiencyInfo;
+    std::set<ASTFileSignature> UniqueModuleSignatures;
+    for (auto &&M : Modules) {
+      std::string RelaxedHashModule =
+          M.second.ModuleName + '-' + M.second.RelaxedContextHash;
+      auto &BuiltModulesInfo = RelaxedHashesEfficiencyInfo[RelaxedHashModule];
+      BuiltModulesInfo.BuiltModules.push_back(&M.second);
+      auto InsertionResult =
+          UniqueModuleSignatures.insert(M.second.ModuleSignature);
+      if (InsertionResult.second)
+        BuiltModulesInfo.UniqueASTFileSignatures++;
+    }
+
+    size_t TotalStrictContextHashModules = Modules.size();
+    size_t TotalRelaxedHashModules = RelaxedHashesEfficiencyInfo.size();
+    auto PercentageModuleNumberIncrease =
+        100 * ((TotalStrictContextHashModules - TotalRelaxedHashModules) /
+               TotalRelaxedHashModules);
+
+    OS << "Total relaxed hash modules: " << TotalRelaxedHashModules << "\n";
+    OS << "Total unique AST signatures: " << UniqueModuleSignatures.size()
+       << "\n";
+    OS << "Total strict context hash modules: " << TotalStrictContextHashModules
+       << "\n";
+    OS << "Module number increase: " << PercentageModuleNumberIncrease
+       << "%\n\n";
+
+    OS << "Details:\n";
+    for (auto &&It : RelaxedHashesEfficiencyInfo) {
+      auto &Duplicates = It.second.BuiltModules;
+      size_t NumDuplicates = Duplicates.size();
+
+      assert(NumDuplicates > 0 && "Cannot have a relaxed hash module that "
+                                  "doesn't map to at least a strict"
+                                  "one!");
+
+      if (NumDuplicates > 1) {
+        OS << "Relaxed hash module: " << It.first << " gets duplicated as ("
+           << It.second.UniqueASTFileSignatures << "/" << NumDuplicates
+           << ") modules:\n\n";
+
+        auto OutputModuleDep = [](raw_ostream &OS, ModuleDeps *MD) {
+          OS << MD->ModuleName << "-" << MD->ContextHash;
+        };
+
+        auto DuplicatesIt = Duplicates.begin();
+        OutputModuleDep(OS, *DuplicatesIt);
+        ++DuplicatesIt;
+        for (auto End = Duplicates.end(); DuplicatesIt != End; ++DuplicatesIt) {
+          OS << "; ";
+          OutputModuleDep(OS, *DuplicatesIt);
+        }
+        OS << "\n\n";
+      }
+    }
+  }
+
 private:
   StringRef lookupPCMPath(ClangModuleDep CMD) {
     return Modules[ContextModulePair{CMD.ContextHash, CMD.ModuleName, 0}]
         .ImplicitModulePCMPath;
   }
 
   const ModuleDeps &lookupModuleDeps(ClangModuleDep CMD) {
     auto I =
         Modules.find(ContextModulePair{CMD.ContextHash, CMD.ModuleName, 0});
     assert(I != Modules.end());
     return I->second;
   };
 
+  struct BuiltModulesEfficiencyInfo {
+    std::vector<ModuleDeps *> BuiltModules;
+    size_t UniqueASTFileSignatures;
+  };
+
   struct ContextModulePair {
     std::string ContextHash;
     std::string ModuleName;
     mutable size_t InputIndex;
 
     bool operator==(const ContextModulePair &Other) const {
       return ContextHash == Other.ContextHash && ModuleName == Other.ModuleName;
     }
Pool.async([I, &Lock, &Index, &Inputs, &HadErrors, &FD, &WorkerTools,
       }
     });
   }
   Pool.wait();
 
   if (Format == ScanningOutputFormat::Full)
     FD.printFullOutput(llvm::outs());
 
+  if (GatherMetrics)
+    FD.computeAndPrintBuildMetrics(llvm::errs());
+
   return HadErrors;
 }