Merge pull request #28566 from davidungar/renaming-dependencies-2

Rename older dependency graph to "CoarseGrainedDependencyGraph"

Author: David Ungar

include/swift/Driver/DependencyGraph.h renamed to include/swift/Driver/CoarseGrainedDependencyGraph.h

@@ -1,4 +1,4 @@
-//===--- DependencyGraph.h - Track intra-module dependencies ----*- C++ -*-===//
+//===- CoarseGrainedDependencyGraph.h - Track intra-module dependencies -*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_DRIVER_DEPENDENCYGRAPH_H
-#define SWIFT_DRIVER_DEPENDENCYGRAPH_H
+#ifndef SWIFT_DRIVER_COARSEGRAINEDDEPENDENCYGRAPH_H
+#define SWIFT_DRIVER_COARSEGRAINEDDEPENDENCYGRAPH_H
 
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/Basic/LLVM.h"
@@ -36,15 +36,15 @@ namespace swift {
 
 class UnifiedStatsReporter;
 
-/// The non-templated implementation of DependencyGraph.
+/// The non-templated implementation of CoarseGrainedDependencyGraph.
 ///
-/// \see DependencyGraph
-class DependencyGraphImpl {
+/// \see CoarseGrainedDependencyGraph
+class CoarseGrainedDependencyGraphImpl {
 public:
   /// Possible dependency kinds.
   ///
-  /// Clients of DependencyGraph should have no reason to use this type.
-  /// It is only used in the implementation.
+  /// Clients of CoarseGrainedDependencyGraph should have no reason to use this
+  /// type. It is only used in the implementation.
   enum class DependencyKind : uint8_t;
 
   /// Describes the result of loading a dependency file for a particular node.
@@ -62,15 +62,17 @@ class DependencyGraphImpl {
     AffectsDownstream
   };
 
-  /// The non-templated implementation of DependencyGraph::MarkTracer.
+  /// The non-templated implementation of
+  /// CoarseGrainedDependencyGraph::MarkTracer.
   ///
-  /// \see DependencyGraph::MarkTracer
+  /// \see CoarseGrainedDependencyGraph::MarkTracer
   class MarkTracerImpl {
     class Entry;
     llvm::DenseMap<const void *, SmallVector<Entry, 4>> Table;
     UnifiedStatsReporter *Stats;
 
-    friend class DependencyGraphImpl;
+    friend class CoarseGrainedDependencyGraphImpl;
+
   protected:
     explicit MarkTracerImpl(UnifiedStatsReporter *Stats);
     ~MarkTracerImpl();
@@ -154,7 +156,7 @@ class DependencyGraphImpl {
     (void)newlyInserted;
   }
 
-  /// See DependencyGraph::markTransitive.
+  /// See CoarseGrainedDependencyGraph::markTransitive.
 
   void markTransitive(SmallVectorImpl<const void *> &visited,
                       const void *node, MarkTracerImpl *tracer = nullptr);
@@ -196,7 +198,7 @@ class DependencyGraphImpl {
 /// The graph also supports a "mark" operation, which is intended to track
 /// nodes that have been not just visited but transitively marked through.
 template <typename T>
-class DependencyGraph : public DependencyGraphImpl {
+class CoarseGrainedDependencyGraph : public CoarseGrainedDependencyGraphImpl {
   using Traits = llvm::PointerLikeTypeTraits<T>;
   static_assert(Traits::NumLowBitsAvailable >= 0, "not a pointer-like type");
 
@@ -210,7 +212,8 @@ class DependencyGraph : public DependencyGraphImpl {
   }
 
 public:
-  /// Traces the graph traversal performed in DependencyGraph::markTransitive.
+  /// Traces the graph traversal performed in
+  /// CoarseGrainedDependencyGraph::markTransitive.
   ///
   /// This is intended to be a debugging aid.
   class MarkTracer : public MarkTracerImpl {
@@ -240,8 +243,8 @@ class DependencyGraph : public DependencyGraphImpl {
   /// call site can polymorphically call \ref
   /// fine_grained_dependencies::ModuleDepGraph::loadFromPath
   LoadResult loadFromPath(T node, StringRef path, DiagnosticEngine &) {
-    return DependencyGraphImpl::loadFromPath(Traits::getAsVoidPointer(node),
-                                             path);
+    return CoarseGrainedDependencyGraphImpl::loadFromPath(
+        Traits::getAsVoidPointer(node), path);
   }
 
   /// Load "depends" and "provides" data for \p node from a plain string.
@@ -250,16 +253,16 @@ class DependencyGraph : public DependencyGraphImpl {
   ///
   /// \sa loadFromPath
   LoadResult loadFromString(T node, StringRef data) {
-    return DependencyGraphImpl::loadFromString(Traits::getAsVoidPointer(node),
-                                               data);
+    return CoarseGrainedDependencyGraphImpl::loadFromString(
+        Traits::getAsVoidPointer(node), data);
   }
 
   /// Adds \p node to the dependency graph without any connections.
   ///
   /// This can be used for new nodes that may be updated later.
   void addIndependentNode(T node) {
-    return
-        DependencyGraphImpl::addIndependentNode(Traits::getAsVoidPointer(node));
+    return CoarseGrainedDependencyGraphImpl::addIndependentNode(
+        Traits::getAsVoidPointer(node));
   }
 
   /// Marks \p node and all nodes that depend on \p node, and places any nodes
@@ -287,17 +290,17 @@ class DependencyGraph : public DependencyGraphImpl {
   void markTransitive(SmallVector<T, N> &visited, T node,
                       MarkTracer *tracer = nullptr) {
     SmallVector<const void *, N> rawMarked;
-    DependencyGraphImpl::markTransitive(rawMarked,
-                                        Traits::getAsVoidPointer(node),
-                                        tracer);
+    CoarseGrainedDependencyGraphImpl::markTransitive(
+        rawMarked, Traits::getAsVoidPointer(node), tracer);
     // FIXME: How can we avoid this copy?
     copyBack(visited, rawMarked);
   }
 
   template <unsigned N>
   void markExternal(SmallVector<T, N> &visited, StringRef externalDependency) {
     SmallVector<const void *, N> rawMarked;
-    DependencyGraphImpl::markExternal(rawMarked, externalDependency);
+    CoarseGrainedDependencyGraphImpl::markExternal(rawMarked,
+                                                   externalDependency);
     // FIXME: How can we avoid this copy?
     copyBack(visited, rawMarked);
   }
@@ -308,13 +311,14 @@ class DependencyGraph : public DependencyGraphImpl {
   ///
   /// \sa #markTransitive
   bool markIntransitive(T node) {
-    return
-        DependencyGraphImpl::markIntransitive(Traits::getAsVoidPointer(node));
+    return CoarseGrainedDependencyGraphImpl::markIntransitive(
+        Traits::getAsVoidPointer(node));
   }
 
   /// Returns true if \p node has been marked (directly or transitively).
   bool isMarked(T node) const {
-    return DependencyGraphImpl::isMarked(Traits::getAsVoidPointer(node));
+    return CoarseGrainedDependencyGraphImpl::isMarked(
+        Traits::getAsVoidPointer(node));
   }
 };
 

include/swift/Driver/FineGrainedDependencyDriverGraph.h

@@ -17,7 +17,7 @@
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptionSet.h"
-#include "swift/Driver/DependencyGraph.h"
+#include "swift/Driver/CoarseGrainedDependencyGraph.h"
 #include "swift/Driver/Job.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
@@ -107,10 +107,11 @@ class ModuleDepGraphNode : public DepGraphNode {
 
 /// A placeholder allowing the experimental system to fit into the driver
 /// without changing as much code.
-class DependencyGraphImpl {
+class CoarseGrainedDependencyGraphImpl {
 public:
   /// Use the status quo LoadResult for now.
-  using LoadResult = typename swift::DependencyGraphImpl::LoadResult;
+  using LoadResult =
+      typename swift::CoarseGrainedDependencyGraphImpl::LoadResult;
 };
 
 //==============================================================================
@@ -267,11 +268,12 @@ class ModuleDepGraph {
     assert(verify() && "ModuleDepGraph should be fine when created");
   }
 
-  /// Unlike the standard \c DependencyGraph, returns \c
-  /// DependencyGraphImpl::LoadResult::AffectsDownstream when loading a new
-  /// file, i.e. when determining the initial set. Caller compensates.
-  DependencyGraphImpl::LoadResult loadFromPath(const driver::Job *, StringRef,
-                                               DiagnosticEngine &);
+  /// Unlike the standard \c CoarseGrainedDependencyGraph, returns \c
+  /// CoarseGrainedDependencyGraphImpl::LoadResult::AffectsDownstream when
+  /// loading a new file, i.e. when determining the initial set. Caller
+  /// compensates.
+  CoarseGrainedDependencyGraphImpl::LoadResult
+  loadFromPath(const driver::Job *, StringRef, DiagnosticEngine &);
 
   /// For the dot file.
   std::string getGraphID() const { return "driver"; }
@@ -372,12 +374,13 @@ class ModuleDepGraph {
   /// and integrate it into the ModuleDepGraph.
   /// Used both the first time, and to reload the SourceFileDepGraph.
   /// If any changes were observed, indicate same in the return vale.
-  DependencyGraphImpl::LoadResult loadFromBuffer(const driver::Job *,
-                                                 llvm::MemoryBuffer &);
+  CoarseGrainedDependencyGraphImpl::LoadResult
+  loadFromBuffer(const driver::Job *, llvm::MemoryBuffer &);
 
   /// Integrate a SourceFileDepGraph into the receiver.
   /// Integration happens when the driver needs to read SourceFileDepGraph.
-  DependencyGraphImpl::LoadResult integrate(const SourceFileDepGraph &);
+  CoarseGrainedDependencyGraphImpl::LoadResult
+  integrate(const SourceFileDepGraph &);
 
   enum class LocationOfPreexistingNode { nowhere, here, elsewhere };
 

lib/Basic/Statistic.cpp

@@ -18,7 +18,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/SIL/SILFunction.h"
-#include "swift/Driver/DependencyGraph.h"
+#include "swift/Driver/CoarseGrainedDependencyGraph.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/FileSystem.h"

lib/Driver/CMakeLists.txt

@@ -1,8 +1,8 @@
 set(swiftDriver_sources
   Action.cpp
+  CoarseGrainedDependencyGraph.cpp
   Compilation.cpp
   DarwinToolChains.cpp
-  DependencyGraph.cpp
   SourceComparator.cpp
   Driver.cpp
   DriverIncrementalRanges.cpp

lib/Driver/DependencyGraph.cpp renamed to lib/Driver/CoarseGrainedDependencyGraph.cpp

@@ -1,4 +1,4 @@
-//===--- DependencyGraph.cpp - Track intra-module dependencies ------------===//
+//===- CoarseGrainedDependencyGraph.cpp - Track intra-module dependencies -===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,9 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/Driver/CoarseGrainedDependencyGraph.h"
 #include "swift/Basic/ReferenceDependencyKeys.h"
 #include "swift/Basic/Statistic.h"
-#include "swift/Driver/DependencyGraph.h"
 #include "swift/Demangling/Demangle.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
@@ -25,30 +25,31 @@
 
 using namespace swift;
 
-enum class DependencyGraphImpl::DependencyKind : uint8_t {
+enum class CoarseGrainedDependencyGraphImpl::DependencyKind : uint8_t {
   TopLevelName = 1 << 0,
   DynamicLookupName = 1 << 1,
   NominalType = 1 << 2,
   NominalTypeMember = 1 << 3,
   ExternalFile = 1 << 4,
 };
-enum class DependencyGraphImpl::DependencyFlags : uint8_t {
+enum class CoarseGrainedDependencyGraphImpl::DependencyFlags : uint8_t {
   IsCascading = 1 << 0
 };
 
-class DependencyGraphImpl::MarkTracerImpl::Entry {
+class CoarseGrainedDependencyGraphImpl::MarkTracerImpl::Entry {
 public:
   const void *Node;
   StringRef Name;
   DependencyMaskTy KindMask;
 };
 
-DependencyGraphImpl::MarkTracerImpl::MarkTracerImpl(UnifiedStatsReporter *Stats)
-  : Stats(Stats) {}
-DependencyGraphImpl::MarkTracerImpl::~MarkTracerImpl() = default;
+CoarseGrainedDependencyGraphImpl::MarkTracerImpl::MarkTracerImpl(
+    UnifiedStatsReporter *Stats)
+    : Stats(Stats) {}
+CoarseGrainedDependencyGraphImpl::MarkTracerImpl::~MarkTracerImpl() = default;
 
-using LoadResult = DependencyGraphImpl::LoadResult;
-using DependencyKind = DependencyGraphImpl::DependencyKind;
+using LoadResult = CoarseGrainedDependencyGraphImpl::LoadResult;
+using DependencyKind = CoarseGrainedDependencyGraphImpl::DependencyKind;
 using DependencyCallbackTy = LoadResult(StringRef, DependencyKind, bool);
 using InterfaceHashCallbackTy = LoadResult(StringRef);
 
@@ -211,21 +212,23 @@ parseDependencyFile(llvm::MemoryBuffer &buffer,
   return result;
 }
 
-LoadResult DependencyGraphImpl::loadFromPath(const void *node, StringRef path) {
+LoadResult CoarseGrainedDependencyGraphImpl::loadFromPath(const void *node,
+                                                          StringRef path) {
   auto buffer = llvm::MemoryBuffer::getFile(path);
   if (!buffer)
     return LoadResult::HadError;
   return loadFromBuffer(node, *buffer.get());
 }
 
-LoadResult
-DependencyGraphImpl::loadFromString(const void *node, StringRef data) {
+LoadResult CoarseGrainedDependencyGraphImpl::loadFromString(const void *node,
+                                                            StringRef data) {
   auto buffer = llvm::MemoryBuffer::getMemBuffer(data);
   return loadFromBuffer(node, *buffer);
 }
 
-LoadResult DependencyGraphImpl::loadFromBuffer(const void *node,
-                                               llvm::MemoryBuffer &buffer) {
+LoadResult
+CoarseGrainedDependencyGraphImpl::loadFromBuffer(const void *node,
+                                                 llvm::MemoryBuffer &buffer) {
   auto &provides = Provides[node];
 
   auto dependsCallback = [this, node](StringRef name, DependencyKind kind,
@@ -294,16 +297,16 @@ LoadResult DependencyGraphImpl::loadFromBuffer(const void *node,
                              interfaceHashCallback);
 }
 
-void DependencyGraphImpl::markExternal(SmallVectorImpl<const void *> &visited,
-                                       StringRef externalDependency) {
+void CoarseGrainedDependencyGraphImpl::markExternal(
+    SmallVectorImpl<const void *> &visited, StringRef externalDependency) {
   forEachUnmarkedJobDirectlyDependentOnExternalSwiftdeps(
       externalDependency, [&](const void *node) {
         visited.push_back(node);
         markTransitive(visited, node);
       });
 }
 
-void DependencyGraphImpl::
+void CoarseGrainedDependencyGraphImpl::
     forEachUnmarkedJobDirectlyDependentOnExternalSwiftdeps(
         StringRef externalSwiftDeps, function_ref<void(const void *node)> fn) {
   auto allDependents = Dependencies.find(externalSwiftDeps);
@@ -319,9 +322,9 @@ void DependencyGraphImpl::
   }
 }
 
-void
-DependencyGraphImpl::markTransitive(SmallVectorImpl<const void *> &visited,
-                                    const void *node, MarkTracerImpl *tracer) {
+void CoarseGrainedDependencyGraphImpl::markTransitive(
+    SmallVectorImpl<const void *> &visited, const void *node,
+    MarkTracerImpl *tracer) {
   assert(Provides.count(node) && "node is not in the graph");
   llvm::SpecificBumpPtrAllocator<MarkTracerImpl::Entry> scratchAlloc;
 
@@ -407,7 +410,7 @@ DependencyGraphImpl::markTransitive(SmallVectorImpl<const void *> &visited,
   }
 }
 
-void DependencyGraphImpl::MarkTracerImpl::countStatsForNodeMarking(
+void CoarseGrainedDependencyGraphImpl::MarkTracerImpl::countStatsForNodeMarking(
   const OptionSet<DependencyKind> &Kind, bool IsCascading) const {
 
   if (!Stats)
@@ -439,7 +442,7 @@ void DependencyGraphImpl::MarkTracerImpl::countStatsForNodeMarking(
   }
 }
 
-void DependencyGraphImpl::MarkTracerImpl::printPath(
+void CoarseGrainedDependencyGraphImpl::MarkTracerImpl::printPath(
     raw_ostream &out,
     const void *item,
     llvm::function_ref<void (const void *)> printItem) const {