Merge pull request #60258 from eeckstein/measure-optimizer-performance

SILOptimizer: add an option to profile and measure the runtime of optimization passes.

Author: eeckstein

include/swift/SIL/SILFunction.h

@@ -181,6 +181,16 @@ class SILFunction
   /// to the binary.  A pointer into the module's lookup table.
   StringRef Name;
 
+  /// A single-linked list of snapshots of the function.
+  ///
+  /// Snapshots are copies of the current function at a given point in time.
+  SILFunction *snapshots = nullptr;
+  
+  /// The snapshot ID of this function.
+  ///
+  /// 0 means, it's not a snapshot, but the original function.
+  int snapshotID = 0;
+
   /// The lowered type of the function.
   CanSILFunctionType LoweredType;
 
@@ -437,11 +447,31 @@ class SILFunction
   /// Only for use by FunctionBuilders!
   void setHasOwnership(bool newValue) { HasOwnership = newValue; }
 
+  void setName(StringRef name) {
+    // All the snapshots share the same name.
+    SILFunction *sn = this;
+    do {
+      sn->Name = name;
+    } while ((sn = sn->snapshots) != nullptr);
+  }
+
 public:
   ~SILFunction();
 
   SILModule &getModule() const { return Module; }
 
+  /// Creates a snapshot with a given `ID` from the current function.
+  void createSnapshot(int ID);
+  
+  /// Returns the snapshot with the given `ID` or null if no such snapshot exists.
+  SILFunction *getSnapshot(int ID);
+  
+  /// Restores the current function from a given snapshot.
+  void restoreFromSnapshot(int ID);
+  
+  /// Deletes a snapshot with the `ID`.
+  void deleteSnapshot(int ID);
+
   SILType getLoweredType() const {
     return SILType::getPrimitiveObjectType(LoweredType);
   }

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -20,6 +20,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Chrono.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <vector>
 
@@ -203,6 +204,8 @@ class SILPassManager {
   /// pass manager is destroyed.
   DeserializationNotificationHandler *deserializationNotificationHandler;
 
+  std::chrono::nanoseconds totalPassRuntime = std::chrono::nanoseconds(0);
+
   /// C'tor. It creates and registers all analysis passes, which are defined
   /// in Analysis.def. This is private as it should only be used by
   /// ExecuteSILPipelineRequest.

lib/SIL/IR/SILFunction.cpp

@@ -15,6 +15,7 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILBridgingUtils.h"
+#include "swift/SIL/SILCloner.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
@@ -175,7 +176,7 @@ void SILFunction::init(SILLinkage Linkage, StringRef Name,
                          IsDynamicallyReplaceable_t isDynamic,
                          IsExactSelfClass_t isExactSelfClass,
                          IsDistributed_t isDistributed) {
-  this->Name = Name;
+  setName(Name);
   this->LoweredType = LoweredType;
   this->GenericEnv = genericEnv;
   this->SpecializationInfo = nullptr;
@@ -215,6 +216,8 @@ SILFunction::~SILFunction() {
   // We also need to drop all references if instructions are allocated using
   // an allocator that may recycle freed memory.
   dropAllReferences();
+  if (snapshots)
+    snapshots->~SILFunction();
 
   if (ReplacedFunction) {
     ReplacedFunction->decrementRefCount();
@@ -237,6 +240,96 @@ SILFunction::~SILFunction() {
     destroyFunction({this}, &libswiftSpecificData, sizeof(libswiftSpecificData));
 }
 
+void SILFunction::createSnapshot(int id) {
+  assert(id != 0 && "invalid snapshot ID");
+  assert(!getSnapshot(id) && "duplicate snapshot");
+
+  SILFunction *newSnapshot = new (Module) SILFunction(Module,
+    getLinkage(), getName(), getLoweredFunctionType(), getGenericEnvironment(),
+    getLocation(), isBare(), isTransparent(), isSerialized(),
+    getEntryCount(), isThunk(), getClassSubclassScope(),
+    getInlineStrategy(), getEffectsKind(), getDebugScope(),
+    isDynamicallyReplaceable(), isExactSelfClass(), isDistributed());
+
+  // Copy all relevant properties.
+  // TODO: It's really unfortunate that this needs to be done manually. It would
+  //       be nice if all the properties are encapsulated into a single state,
+  //       which can be copied at once.
+  newSnapshot->SpecializationInfo = SpecializationInfo;
+  newSnapshot->ClangNodeOwner = ClangNodeOwner;
+  newSnapshot->DeclCtxt = DeclCtxt;
+  newSnapshot->Profiler = Profiler;
+  newSnapshot->ReplacedFunction = ReplacedFunction;
+  newSnapshot->RefAdHocRequirementFunction = RefAdHocRequirementFunction;
+  newSnapshot->ObjCReplacementFor = ObjCReplacementFor;
+  newSnapshot->SemanticsAttrSet = SemanticsAttrSet;
+  newSnapshot->SpecializeAttrSet = SpecializeAttrSet;
+  newSnapshot->Availability = Availability;
+  newSnapshot->specialPurpose = specialPurpose;
+  newSnapshot->perfConstraints = perfConstraints;
+  newSnapshot->GlobalInitFlag = GlobalInitFlag;
+  newSnapshot->HasCReferences = HasCReferences;
+  newSnapshot->IsWeakImported = IsWeakImported;
+  newSnapshot->HasOwnership = HasOwnership;
+  newSnapshot->IsWithoutActuallyEscapingThunk = IsWithoutActuallyEscapingThunk;
+  newSnapshot->OptMode = OptMode;
+  newSnapshot->IsStaticallyLinked = IsStaticallyLinked;
+  newSnapshot->copyEffects(this);
+
+  SILFunctionCloner cloner(newSnapshot);
+  cloner.cloneFunction(this);
+
+  newSnapshot->snapshotID = id;
+  newSnapshot->snapshots = this->snapshots;
+  this->snapshots = newSnapshot;
+
+  // The cloner sometimes removes temporary instructions.
+  getModule().flushDeletedInsts();
+}
+
+SILFunction *SILFunction::getSnapshot(int ID) {
+  SILFunction *sn = this;
+  do {
+    if (sn->snapshotID == ID)
+      return sn;
+    sn = sn->snapshots;
+  } while (sn);
+  return nullptr;
+}
+
+void SILFunction::restoreFromSnapshot(int ID) {
+  SILFunction *sn = getSnapshot(ID);
+  assert(sn && "no snapshot found");
+
+  clear();
+  SILFunctionCloner cloner(this);
+  cloner.cloneFunction(sn);
+
+  // Beside the function body, only restore those properties, which are/can be
+  // modified by passes.
+  // TODO: There should be a clear sepratation from initialize-once properties
+  //       (`let`) and properties which can be modified by passes (`var`).
+  copyEffects(sn);
+
+  // The cloner sometimes removes temporary instructions.
+  getModule().flushDeletedInsts();
+}
+
+void SILFunction::deleteSnapshot(int ID) {
+  SILFunction *f = this;
+  do {
+    if (SILFunction *sn = f->snapshots) {
+      if (sn->snapshotID == ID) {
+        f->snapshots = sn->snapshots;
+        sn->snapshots = nullptr;
+        sn->~SILFunction();
+        getModule().flushDeletedInsts();
+        return;
+      }
+    }
+  } while ((f = f->snapshots) != nullptr);
+}
+
 void SILFunction::createProfiler(ASTNode Root, SILDeclRef forDecl,
                                  ForDefinition_t forDefinition) {
   assert(!Profiler && "Function already has a profiler");

lib/SIL/IR/SILModule.cpp

@@ -161,14 +161,20 @@ void SILModule::checkForLeaks() const {
   int instsInModule = std::distance(scheduledForDeletion.begin(),
                                     scheduledForDeletion.end());
   for (const SILFunction &F : *this) {
-    for (const SILBasicBlock &block : F) {
-      instsInModule += std::distance(block.begin(), block.end());
-    }
+    const SILFunction *sn = &F;
+    do {
+      for (const SILBasicBlock &block : *sn) {
+        instsInModule += std::distance(block.begin(), block.end());
+      }
+    } while ((sn = sn->snapshots) != nullptr);
   }
   for (const SILFunction &F : zombieFunctions) {
-    for (const SILBasicBlock &block : F) {
-      instsInModule += std::distance(block.begin(), block.end());
-    }
+    const SILFunction *sn = &F;
+    do {
+      for (const SILBasicBlock &block : F) {
+        instsInModule += std::distance(block.begin(), block.end());
+      }
+    } while ((sn = sn->snapshots) != nullptr);
   }
   for (const SILGlobalVariable &global : getSILGlobals()) {
       instsInModule += std::distance(global.StaticInitializerBlock.begin(),
@@ -434,13 +440,14 @@ void SILModule::invalidateSILLoaderCaches() {
 
 SILFunction *SILModule::removeFromZombieList(StringRef Name) {
   if (auto *Zombie = ZombieFunctionTable.lookup(Name)) {
+    assert(Zombie->snapshotID == 0 && "zombie cannot be a snapthot function");
     ZombieFunctionTable.erase(Name);
     zombieFunctions.remove(Zombie);
 
     // The owner of the function's Name is the ZombieFunctionTable key, which is
     // freed by erase().
     // Make sure nobody accesses the name string after it is freed.
-    Zombie->Name = StringRef();
+    Zombie->setName(StringRef());
     return Zombie;
   }
   return nullptr;
@@ -449,6 +456,7 @@ SILFunction *SILModule::removeFromZombieList(StringRef Name) {
 /// Erase a function from the module.
 void SILModule::eraseFunction(SILFunction *F) {
   assert(!F->isZombie() && "zombie function is in list of alive functions");
+  assert(F->snapshotID == 0 && "cannot erase a snapshot function");
 
   llvm::StringMapEntry<SILFunction*> *entry =
       &*ZombieFunctionTable.insert(std::make_pair(F->getName(), nullptr)).first;
@@ -459,7 +467,7 @@ void SILModule::eraseFunction(SILFunction *F) {
   // the function from the table we need to use the allocated name string from
   // the ZombieFunctionTable.
   FunctionTable.erase(F->getName());
-  F->Name = zombieName;
+  F->setName(zombieName);
 
   // The function is dead, but we need it later (at IRGen) for debug info
   // or vtable stub generation. So we move it into the zombie list.