[clang-doc] Parallelize reducing phase

[DiegoAstiazaran]

Summary

Reduce phase has been parallelized and a execution time was reduced by 60% with this.
The reading of bitcode (bitcode -> Info) was moved to this segment of code parallelized so it now happens just before reducing.

[jakehehrlich]

LGTM other than a couple atomicity issues.

clang-tools-extra/clang-doc/tool/ClangDocMain.cpp

244 ↗

(On Diff #212950)

use std::atomic<bool>

262 ↗

(On Diff #212950)

This isn't technically thread safe. Use an std::atomic<bool>

[DiegoAstiazaran]

Fix atomicity issues.

[juliehockett]

clang-tools-extra/clang-doc/tool/ClangDocMain.cpp

72 ↗

(On Diff #213425)

Can we use the pre-existing concurrency flag instead (https://github.com/llvm/llvm-project/blob/91e5cdfc93729c61c757db4efd4a82670ac7f929/clang/lib/Tooling/AllTUsExecution.cpp#L150)? It seems counterintuitive to have to set two different concurrency flags for one tool.

You'll have to put up a separate patch to expose that flag in the AllTUs header, so that you can access it (see rL344335, as an example).

[DiegoAstiazaran]

Use pre-existing concurrency flag --execute-concurrency instead implementing a new one.

clang-tools-extra/clang-doc/tool/ClangDocMain.cpp

72 ↗

(On Diff #213425)

Done in D65833.

[juliehockett]

LGTM (after comment nit addressed)

clang-tools-extra/clang-doc/tool/ClangDocMain.cpp

249 ↗

(On Diff #213968)

nit: comment about where this var is coming from

[DiegoAstiazaran]

Add comment

clang-tools-extra/trunk/clang-doc/tool/ClangDocMain.cpp

 #include "Generators.h"
 #include "Representation.h"
 #include "clang/AST/AST.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/FrontendActions.h"
+#include "clang/Tooling/AllTUsExecution.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Execution.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/raw_ostream.h"
+#include <atomic>
 #include <string>
 
 using namespace clang::ast_matchers;
 using namespace clang::tooling;
 using namespace clang;
 
 static llvm::cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 static llvm::cl::OptionCategory ClangDocCategory("clang-doc options");
llvm::Expected<llvm::SmallString<128>> getInfoOutputFile(StringRef Root,
   llvm::sys::path::append(Path, RelativePath);
   if (CreateDirectory(Path))
     return llvm::make_error<llvm::StringError>("Unable to create directory.\n",
                                                llvm::inconvertibleErrorCode());
   llvm::sys::path::append(Path, Name + Ext);
   return Path;
 }
 
-// Iterate through tool results and build string map of info vectors from the
-// encoded bitstreams.
-bool bitcodeResultsToInfos(
-    tooling::ToolResults &Results,
-    llvm::StringMap<std::vector<std::unique_ptr<doc::Info>>> &Output) {
-  bool Err = false;
-  Results.forEachResult([&](StringRef Key, StringRef Value) {
-    llvm::BitstreamCursor Stream(Value);
-    doc::ClangDocBitcodeReader Reader(Stream);
-    auto Infos = Reader.readBitcode();
-    if (!Infos) {
-      llvm::errs() << toString(Infos.takeError()) << "\n";
-      Err = true;
-      return;
-    }
-    for (auto &I : Infos.get()) {
-      auto R =
-          Output.try_emplace(Key, std::vector<std::unique_ptr<doc::Info>>());
-      R.first->second.emplace_back(std::move(I));
-    }
-  });
-  return Err;
-}
-
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
   std::error_code OK;
 
   ExecutorName.setInitialValue("all-TUs");
   auto Exec = clang::tooling::createExecutorFromCommandLineArgs(
       argc, argv, ClangDocCategory);
 
else {
       return 1;
     }
   }
 
   // Collect values into output by key.
   // In ToolResults, the Key is the hashed USR and the value is the
   // bitcode-encoded representation of the Info object.
   llvm::outs() << "Collecting infos...\n";
-  llvm::StringMap<std::vector<std::unique_ptr<doc::Info>>> USRToInfos;
-  if (bitcodeResultsToInfos(*Exec->get()->getToolResults(), USRToInfos))
-    return 1;
+  llvm::StringMap<std::vector<StringRef>> USRToBitcode;
+  Exec->get()->getToolResults()->forEachResult(
+      [&](StringRef Key, StringRef Value) {
+        auto R = USRToBitcode.try_emplace(Key, std::vector<StringRef>());
+        R.first->second.emplace_back(Value);
+      });
 
   // First reducing phase (reduce all decls into one info per decl).
-  llvm::outs() << "Reducing " << USRToInfos.size() << " infos...\n";
-  for (auto &Group : USRToInfos) {
-    auto Reduced = doc::mergeInfos(Group.getValue());
+  llvm::outs() << "Reducing " << USRToBitcode.size() << " infos...\n";
+  std::atomic<bool> Error;
+  Error = false;
+  // ExecutorConcurrency is a flag exposed by AllTUsExecution.h
+  llvm::ThreadPool Pool(ExecutorConcurrency == 0 ? llvm::hardware_concurrency()
+                                                 : ExecutorConcurrency);
+  for (auto &Group : USRToBitcode) {
+    Pool.async([&]() {
+      std::vector<std::unique_ptr<doc::Info>> Infos;
+
+      for (auto &Bitcode : Group.getValue()) {
+        llvm::BitstreamCursor Stream(Bitcode);
+        doc::ClangDocBitcodeReader Reader(Stream);
+        auto ReadInfos = Reader.readBitcode();
+        if (!ReadInfos) {
+          llvm::errs() << toString(ReadInfos.takeError()) << "\n";
+          Error = true;
+          return;
+        }
+        std::move(ReadInfos->begin(), ReadInfos->end(),
+                  std::back_inserter(Infos));
+      }
+
+      auto Reduced = doc::mergeInfos(Infos);
       if (!Reduced) {
         llvm::errs() << llvm::toString(Reduced.takeError());
-      continue;
+        return;
       }
 
       doc::Info *I = Reduced.get().get();
       auto InfoPath = getInfoOutputFile(OutDirectory, I->Path, I->extractName(),
                                         "." + Format);
       if (!InfoPath) {
         llvm::errs() << toString(InfoPath.takeError()) << "\n";
-      return 1;
+        Error = true;
+        return;
       }
       std::error_code FileErr;
       llvm::raw_fd_ostream InfoOS(InfoPath.get(), FileErr,
-                                llvm::sys::fs::OF_None);
+                                  llvm::sys::fs::F_None);
       if (FileErr != OK) {
-      llvm::errs() << "Error opening info file: " << FileErr.message() << "\n";
-      continue;
+        llvm::errs() << "Error opening info file: " << FileErr.message()
+                     << "\n";
+        return;
       }
 
       // Add a reference to this Info in the Index
       clang::doc::Generator::addInfoToIndex(CDCtx.Idx, I);
 
       if (auto Err = G->get()->generateDocForInfo(I, InfoOS, CDCtx))
         llvm::errs() << toString(std::move(Err)) << "\n";
+    });
   }
 
+  Pool.wait();
+
+  if (Error)
+    return 1;
+
   llvm::outs() << "Generating assets for docs...\n";
   if (!G->get()->createResources(CDCtx))
     return 1;
 
   return 0;
 }