Merge pull request #13597 from vedantk/master

[Coverage] Refactor SIL generation for profiling

Author: vedantk

include/swift/SIL/SILCoverageMap.h

@@ -73,6 +73,9 @@ class SILCoverageMap : public llvm::ilist_node<SILCoverageMap>,
   // Tail-allocated expression list.
   MutableArrayRef<llvm::coverage::CounterExpression> Expressions;
 
+  // Whether the coverage mapping's name data is in the profile symbol table.
+  bool HasSymtabEntry;
+
   // Disallow copying into temporary objects.
   SILCoverageMap(const SILCoverageMap &other) = delete;
   SILCoverageMap &operator=(const SILCoverageMap &) = delete;
@@ -108,6 +111,14 @@ class SILCoverageMap : public llvm::ilist_node<SILCoverageMap>,
     return Expressions;
   }
 
+  /// Check whether this coverage mapping can reference its name data within
+  /// the profile symbol table.
+  bool hasSymtabEntry() const { return HasSymtabEntry; }
+
+  /// Guarantee that this coverage mapping can reference its name data within
+  /// the profile symbol table.
+  void setSymtabEntryGuaranteed() { HasSymtabEntry = true; }
+
   void printCounter(llvm::raw_ostream &OS, llvm::coverage::Counter C) const;
 
   /// Print the coverage map.

include/swift/SIL/SILFunction.h

@@ -23,6 +23,7 @@
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILLinkage.h"
 #include "swift/SIL/SILPrintContext.h"
+#include "swift/SIL/SILProfiler.h"
 #include "llvm/ADT/StringMap.h"
 
 /// The symbol name used for the program entry point function.
@@ -132,6 +133,10 @@ class SILFunction
   /// The source location and scope of the function.
   const SILDebugScope *DebugScope;
 
+  /// The profiler for instrumentation based profiling, or null if profiling is
+  /// disabled.
+  SILProfiler *Profiler = nullptr;
+
   /// The function's bare attribute. Bare means that the function is SIL-only
   /// and does not require debug info.
   unsigned Bare : 1;
@@ -251,8 +256,24 @@ class SILFunction
     return SILFunctionConventions(LoweredType, getModule());
   }
 
+  SILProfiler *getProfiler() const { return Profiler; }
+
+  void setProfiler(SILProfiler *InheritedProfiler) {
+    assert(!Profiler && "Function already has a profiler");
+    Profiler = InheritedProfiler;
+  }
+
+  void createProfiler(Decl *D) {
+    assert(!Profiler && "Function already has a profiler");
+    Profiler = SILProfiler::create(Module, D);
+  }
+
+  void discardProfiler() { Profiler = nullptr; }
+
   ProfileCounter getEntryCount() const { return EntryCount; }
 
+  void setEntryCount(ProfileCounter Count) { EntryCount = Count; }
+
   bool isNoReturnFunction() const;
 
   /// Unsafely rewrite the lowered type of this function.

include/swift/SIL/SILModule.h

@@ -42,6 +42,7 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/ilist.h"
+#include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/raw_ostream.h"
 #include <functional>
@@ -220,7 +221,10 @@ class SILModule {
   /// constructed. In certain cases this was before all Modules had been loaded
   /// causing us to not
   std::unique_ptr<SerializedSILLoader> SILLoader;
-  
+
+  /// The indexed profile data to be used for PGO, or nullptr.
+  std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;
+
   /// True if this SILModule really contains the whole module, i.e.
   /// optimizations can assume that they see the whole module.
   bool wholeModule;
@@ -626,6 +630,12 @@ class SILModule {
     Stage = s;
   }
 
+  llvm::IndexedInstrProfReader *getPGOReader() const { return PGOReader.get(); }
+
+  void setPGOReader(std::unique_ptr<llvm::IndexedInstrProfReader> IPR) {
+    PGOReader = std::move(IPR);
+  }
+
   /// \brief Run the SIL verifier to make sure that all Functions follow
   /// invariants.
   void verify() const;

include/swift/SIL/SILProfiler.h

@@ -0,0 +1,101 @@
+//===--- SILProfiler.h - Instrumentation based profiling ===-----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines SILProfiler, which contains the profiling state for one
+// function. It's used to drive PGO and generate code coverage reports.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_PROFILER_H
+#define SWIFT_SIL_PROFILER_H
+
+#include "swift/AST/ASTNode.h"
+#include "swift/AST/Stmt.h"
+#include "swift/Basic/ProfileCounter.h"
+#include "swift/SIL/FormalLinkage.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace swift {
+
+class AbstractFunctionDecl;
+class SILCoverageMap;
+class SILModule;
+
+/// SILProfiler - Maps AST nodes to profile counters.
+class SILProfiler : public SILAllocated<SILProfiler> {
+private:
+  SILModule &M;
+
+  Decl *Root;
+
+  bool EmitCoverageMapping;
+
+  SILCoverageMap *CovMap = nullptr;
+
+  StringRef CurrentFileName;
+
+  std::string PGOFuncName;
+
+  uint64_t FunctionHash = 0;
+
+  unsigned NumRegionCounters = 0;
+
+  llvm::DenseMap<ASTNode, unsigned> RegionCounterMap;
+
+  llvm::DenseMap<ASTNode, ProfileCounter> PGORegionLoadedCounterMap;
+
+  llvm::DenseMap<ASTNode, ASTNode> PGORegionCondToParentMap;
+
+  std::vector<std::tuple<std::string, uint64_t, std::string>> CoverageData;
+
+  SILProfiler(SILModule &M, Decl *D, bool EmitCoverageMapping)
+      : M(M), Root(D), EmitCoverageMapping(EmitCoverageMapping) {}
+
+public:
+  static SILProfiler *create(SILModule &M, Decl *D);
+
+  /// Check if the function is set up for profiling.
+  bool hasRegionCounters() const { return NumRegionCounters != 0; }
+
+  /// Get the execution count corresponding to \p Node from a profile, if one
+  /// is available.
+  ProfileCounter getExecutionCount(ASTNode Node);
+
+  /// Get the node's parent ASTNode (e.g to get the parent IfStmt or IfCond of
+  /// a condition), if one is available.
+  Optional<ASTNode> getPGOParent(ASTNode Node);
+
+  /// Get the function name mangled for use with PGO.
+  StringRef getPGOFuncName() const { return PGOFuncName; }
+
+  /// Get the function hash.
+  uint64_t getPGOFuncHash() const { return FunctionHash; }
+
+  /// Get the number of region counters.
+  unsigned getNumRegionCounters() const { return NumRegionCounters; }
+
+  /// Get the mapping from \c ASTNode to its corresponding profile counter.
+  const llvm::DenseMap<ASTNode, unsigned> &getRegionCounterMap() const {
+    return RegionCounterMap;
+  }
+
+  /// Increment the number of counter updates associated with this profiler.
+  void recordCounterUpdate();
+
+private:
+  /// Map counters to ASTNodes and set them up for profiling the function.
+  void assignRegionCounters();
+};
+
+} // end namespace swift
+
+#endif // SWIFT_SIL_PROFILER_H

lib/IRGen/GenCoverage.cpp

@@ -43,6 +43,15 @@ void IRGenModule::emitCoverageMapping() {
   if (Mappings.empty())
     return;
 
+  assert(std::all_of(Mappings.begin(), Mappings.end(),
+                     [](const SILCoverageMap &M) {
+                       // TODO: We should use this check defensively s.t we
+                       // never emit malformed coverage data, instead of just
+                       // using it as a debugging tool.
+                       return M.hasSymtabEntry();
+                     }) &&
+         "Missing symtab entry for coverage mapping");
+
   std::vector<StringRef> Files;
   for (const auto &M : Mappings)
     if (std::find(Files.begin(), Files.end(), M.getFile()) == Files.end())

lib/SIL/CMakeLists.txt

@@ -27,6 +27,7 @@ add_swift_library(swiftSIL STATIC
   SILModule.cpp
   SILOpenedArchetypesTracker.cpp
   SILPrinter.cpp
+  SILProfiler.cpp
   SILSuccessor.cpp
   SILType.cpp
   SILValue.cpp

lib/SIL/SILCoverageMap.cpp

@@ -44,7 +44,7 @@ SILCoverageMap::create(SILModule &M, StringRef Filename, StringRef Name,
 }
 
 SILCoverageMap::SILCoverageMap(uint64_t Hash, bool External)
-    : External(External), Hash(Hash) {}
+    : External(External), Hash(Hash), HasSymtabEntry(false) {}
 
 SILCoverageMap::~SILCoverageMap() {}