[llvm-cov] Skip unnecessary coverage computations for "export -summary-only".

[Dor1s]

Summary

This speeds up export "summary-only" execution by an order of magnitude or two,
depending on number of threads used for prepareFileReports execution.

Also includes minor refactoring for splitting render of summary and detailed data
in two independent methods.

[Dor1s]

Refactor methods for file rendering

[Dor1s]

Clean up the code

[vsk]

Looks good, thanks!

tools/llvm-cov/CodeCoverage.cpp

 #include "llvm/Support/Program.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 #include <functional>
 #include <map>
+#include <sstream>
 #include <system_error>
 
 using namespace llvm;
 using namespace coverage;
 
 void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping,
                               const CoverageViewOptions &Options,
                               raw_ostream &OS);
void CodeCoverageTool::writeSourceFileView(StringRef SourceFile,
 
   View->print(*OS.get(), /*Wholefile=*/true,
               /*ShowSourceName=*/ShowFilenames,
               /*ShowTitle=*/ViewOpts.hasOutputDirectory());
   Printer->closeViewFile(std::move(OS));
 }
 
 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
+  errs() << "Started: ";
+  printTimestamp();
   cl::opt<std::string> CovFilename(
       cl::Positional, cl::desc("Covered executable or object file."));
 
   cl::list<std::string> CovFilenames(
       "object", cl::desc("Coverage executable or object file"), cl::ZeroOrMore,
       cl::CommaSeparated);
 
   cl::list<std::string> InputSourceFiles(
int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
   switch (Cmd) {
   case Show:
     return doShow(argc, argv, commandLineParser);
   case Report:
     return doReport(argc, argv, commandLineParser);
   case Export:
     return doExport(argc, argv, commandLineParser);
   }
+  errs() << "Done: ";
+  printTimestamp();
   return 0;
 }
 
 int CodeCoverageTool::doShow(int argc, const char **argv,
                              CommandLineParserType commandLineParser) {
 
   cl::OptionCategory ViewCategory("Viewing options");
 

tools/llvm-cov/CoverageExporterJson.h

class CoverageExporterJson : public CoverageExporter {
   void renderFunctions(
       const iterator_range<coverage::FunctionRecordIterator> &Functions);
 
   /// \brief Render an array of all the source files, also pass back a Summary.
   void renderFiles(ArrayRef<std::string> SourceFiles,
                    ArrayRef<FileCoverageSummary> FileReports);
 
   /// \brief Render a single file.
-  void renderFile(const coverage::CoverageData &FileCoverage,
+  void renderFile(const std::string &Filename,
+                  const FileCoverageSummary &FileReport);
+
+  /// \brief Render summary for a single file.
+  void renderFileCoverage(const coverage::CoverageData &FileCoverage,
                           const FileCoverageSummary &FileReport);
 
   /// \brief Render a CoverageSegment.
   void renderSegment(const coverage::CoverageSegment &Segment);
 
   /// \brief Render an ExpansionRecord.
   void renderExpansion(const coverage::ExpansionRecord &Expansion);
 
   /// \brief Render a list of CountedRegions.

tools/llvm-cov/CoverageExporterJson.cpp

 
 void CoverageExporterJson::emitArrayEnd() {
   State.pop();
   assert((State.size() >= 1) && "Closed too many JSON elements");
   OS << "]";
 }
 
 void CoverageExporterJson::renderRoot() {
+  errs() << "renderRoot(), getting unique source files: ";
+  printTimestamp();
   std::vector<std::string> SourceFiles;
   for (StringRef SF : Coverage.getUniqueSourceFiles())
     SourceFiles.emplace_back(SF);
   renderRoot(SourceFiles);
 }
 
 void CoverageExporterJson::renderRoot(
     const std::vector<std::string> &SourceFiles) {
+  errs() << "renderRoot(sourceFiles): ";
+  printTimestamp();
   // Start Root of JSON object.
   emitDictStart();
 
   emitDictElement("version", LLVM_COVERAGE_EXPORT_JSON_STR);
   emitDictElement("type", LLVM_COVERAGE_EXPORT_JSON_TYPE_STR);
   emitDictKey("data");
 
   // Start List of Exports.
   emitArrayStart();
 
   // Start Export.
   emitDictStart();
 
   emitDictKey("files");
 
   FileCoverageSummary Totals = FileCoverageSummary("Totals");
+  errs() << "prepareFileReports: ";
+  printTimestamp();
   auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
                                                         SourceFiles, Options);
+  errs() << "renderFiles: ";
+  printTimestamp();
   renderFiles(SourceFiles, FileReports);
+  errs() << "render leftovers: ";
+  printTimestamp();
 
   // Skip functions-level information for summary-only export mode.
   if (!Options.ExportSummaryOnly) {
     emitDictKey("functions");
     renderFunctions(Coverage.getCoveredFunctions());
   }
 
   emitDictKey("totals");

 
 void CoverageExporterJson::renderFiles(
     ArrayRef<std::string> SourceFiles,
     ArrayRef<FileCoverageSummary> FileReports) {
   // Start List of Files.
   emitArrayStart();
 
   for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I) {
-    // Render the file.
-    auto FileCoverage = Coverage.getCoverageForFile(SourceFiles[I]);
-    renderFile(FileCoverage, FileReports[I]);
+    renderFile(SourceFiles[I], FileReports[I]);
   }
 
   // End List of Files.
   emitArrayEnd();
 }
 
-void CoverageExporterJson::renderFile(
-    const coverage::CoverageData &FileCoverage,
+void CoverageExporterJson::renderFile(const std::string &Filename,
                                       const FileCoverageSummary &FileReport) {
    // Start File.
   emitDictStart();
 
-  emitDictElement("filename", FileCoverage.getFilename());
+  emitDictElement("filename", Filename);
   
-  // Skip segments and expansions for summary-only export mode.
   if (!Options.ExportSummaryOnly) {
-    emitDictKey("segments");
+    // Calculate and render detailed coverage information for given file.
+    auto FileCoverage = Coverage.getCoverageForFile(Filename);
+    renderFileCoverage(FileCoverage, FileReport);
+  }
+
+  emitDictKey("summary");
+  renderSummary(FileReport);
+
+  // End File.
+  emitDictEnd();
+}
+
+
+void CoverageExporterJson::renderFileCoverage(
+    const coverage::CoverageData &FileCoverage,
+    const FileCoverageSummary &FileReport) {
 
-    // Start List of Segments.
-    emitArrayStart();
 
-    for (const auto &Segment : FileCoverage)
-      renderSegment(Segment);
 
-    // End List of Segments.
-    emitArrayEnd();
 
-    emitDictKey("expansions");
 
-    // Start List of Expansions.
-    emitArrayStart();
 
-    for (const auto &Expansion : FileCoverage.getExpansions())
-      renderExpansion(Expansion);
 
-    // End List of Expansions.
-    emitArrayEnd();
-  }
 
-  emitDictKey("summary");
-  renderSummary(FileReport);
-
-  // End File.
-  emitDictEnd();
-}
-
 void CoverageExporterJson::renderSegment(
     const coverage::CoverageSegment &Segment) {
   // Start Segment.
   emitArrayStart();
 
   emitArrayElement(Segment.Line);
   emitArrayElement(Segment.Col);
   emitArrayElement(Segment.Count);

tools/llvm-cov/CoverageReport.h

public:
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files) const;
 
   /// Render file reports for the files specified in \p Files and the functions
   /// in \p Filters.
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files,
                          const CoverageFiltersMatchAll &Filters) const;
 };
 
+void printTimestamp();
+
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEREPORT_H

tools/llvm-cov/CoverageReport.cpp

 #include "RenderingSupport.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
 #include <numeric>
 
+#include <chrono>
+#include <ctime>
+#include <iostream>
+
 using namespace llvm;
 
 namespace {
 
 /// \brief Helper struct which prints trimmed and aligned columns.
 struct Column {
   enum TrimKind { NoTrim, WidthTrim, RightTrim };
 
for (const FileCoverageSummary &FCS : FileReports)
         render(FCS, OS);
   }
 
   renderDivider(FileReportColumns, OS);
   OS << "\n";
   render(Totals, OS);
 }
 
+void printTimestamp() {
+  using namespace std::chrono;
+  system_clock::time_point today = system_clock::now();
+  time_t tt = system_clock::to_time_t ( today );
+  std::cerr << ctime(&tt) << "\n";
+}
+
 } // end namespace llvm