Merge branch 'main' into elsh/pcmo-fixes

Author: elsh

CHANGELOG.md

@@ -75,6 +75,20 @@ And the module structure to support such applications looks like this:
   checking, and now even an actor which is "on a queue which is targeting 
   another specific queue" can be properly detected using these APIs.
 
+* Closures can now appear in pack expansion expressions, which allows you to
+  construct a parameter pack of closures where each closure captures the
+  corresponding element of some other parameter pack. For example:
+
+  ```swift
+  struct Manager<each T> {
+    let fn: (repeat () -> (each T))
+
+    init(_ t: repeat each T) {
+      fn = (repeat { each t })
+    }
+  }
+  ```
+
 * [SE-0431][]:
   You can now require a function value to carry its actor isolation
   dynamically in a way that can be directly read by clients:

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -281,7 +281,7 @@ private func transitivelyErase(load: LoadInst, _ context: SimplifyContext) {
 
 private extension Value {
   func canBeCopied(into function: Function, _ context: SimplifyContext) -> Bool {
-    if !function.isSerialized {
+    if !function.isAnySerialized {
       return true
     }
 
@@ -297,7 +297,7 @@ private extension Value {
 
     while let value = worklist.pop() {
       if let fri = value as? FunctionRefInst {
-        if !fri.referencedFunction.hasValidLinkageForFragileRef {
+        if !fri.referencedFunction.hasValidLinkageForFragileRef(function.serializedKind) {
           return false
         }
       }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -655,9 +655,8 @@ extension FullApplySite {
       return false
     }
     // Cannot inline a non-inlinable function it an inlinable function.
-    if parentFunction.isSerialized,
-       let calleeFunction = referencedFunction,
-       !calleeFunction.isSerialized {
+    if let calleeFunction = referencedFunction,
+       !calleeFunction.canBeInlinedIntoCaller(parentFunction.serializedKind) {
       return false
     }
 

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -136,7 +136,37 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   }
   public var isSerialized: Bool { bridged.isSerialized() }
 
-  public var hasValidLinkageForFragileRef: Bool { bridged.hasValidLinkageForFragileRef() }
+  public var isAnySerialized: Bool { bridged.isAnySerialized() }
+
+  public enum SerializedKind {
+    case notSerialized, serialized, serializedForPackage
+  }
+
+  public var serializedKind: SerializedKind {
+    switch bridged.getSerializedKind() {
+    case .IsNotSerialized: return .notSerialized
+    case .IsSerialized: return .serialized
+    case .IsSerializedForPackage: return .serializedForPackage
+    default: fatalError()
+    }
+  }
+
+  private func serializedKindBridged(_ arg: SerializedKind) -> BridgedFunction.SerializedKind {
+    switch arg {
+    case .notSerialized: return .IsNotSerialized
+    case .serialized: return .IsSerialized
+    case .serializedForPackage: return .IsSerializedForPackage
+    default: fatalError()
+    }
+  }
+
+  public func canBeInlinedIntoCaller(_ kind: SerializedKind) -> Bool {
+    bridged.canBeInlinedIntoCaller(serializedKindBridged(kind))
+  }
+
+  public func hasValidLinkageForFragileRef(_ kind: SerializedKind) -> Bool {
+    bridged.hasValidLinkageForFragileRef(serializedKindBridged(kind))
+  }
 
   public enum ThunkKind {
     case noThunk, thunk, reabstractionThunk, signatureOptimizedThunk

benchmark/CMakeLists.txt

@@ -40,6 +40,7 @@ set(SWIFT_BENCH_MODULES
     single-source/ArrayRemoveAll
     single-source/ArraySetElement
     single-source/ArraySubscript
+    single-source/AsyncTree
     single-source/BinaryFloatingPointConversionFromBinaryInteger
     single-source/BinaryFloatingPointProperties
     single-source/BitCount

benchmark/single-source/AsyncTree.swift

@@ -0,0 +1,77 @@
+//===--- AsyncTree.swift -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 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
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+import Dispatch
+
+public var benchmarks: [BenchmarkInfo] {
+  guard #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) else {
+    return []
+  }
+  return [
+    BenchmarkInfo(
+      name: "AsyncTree.100",
+      runFunction: run_AsyncTree(treeSize: 100),
+      tags: [.concurrency]
+    ),
+    BenchmarkInfo(
+      name: "AsyncTree.5000",
+      runFunction: run_AsyncTree(treeSize: 5000),
+      tags: [.concurrency]
+    )
+  ]
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+private actor MyActor {
+  let g: DispatchGroup
+
+  init(_ g: DispatchGroup) {
+    self.g = g
+  }
+
+  func test(_ n: Int) {
+    let L = n / 2
+    let R = n - 1 - L
+
+    if L > 0 {
+      Task {
+        self.test(L)
+      }
+    }
+
+    if R > 0 {
+      Task {
+        self.test(R)
+      }
+    }
+
+    g.leave()
+  }
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+private func run_AsyncTree(treeSize: Int) -> (Int) -> Void {
+  return { n in
+    for _ in 0..<n {
+      let g = DispatchGroup()
+      for _ in 0..<treeSize {
+        g.enter()
+      }
+      let actor = MyActor(g)
+      Task {
+        await actor.test(treeSize)
+      }
+      g.wait()
+    }
+  }
+}

benchmark/utils/main.swift

@@ -28,6 +28,7 @@ import ArrayOfRef
 import ArrayRemoveAll
 import ArraySetElement
 import ArraySubscript
+import AsyncTree
 import BinaryFloatingPointConversionFromBinaryInteger
 import BinaryFloatingPointProperties
 import BitCount
@@ -223,6 +224,7 @@ register(ArrayOfRef.benchmarks)
 register(ArrayRemoveAll.benchmarks)
 register(ArraySetElement.benchmarks)
 register(ArraySubscript.benchmarks)
+register(AsyncTree.benchmarks)
 register(BinaryFloatingPointConversionFromBinaryInteger.benchmarks)
 register(BinaryFloatingPointProperties.benchmarks)
 register(BitCount.benchmarks)

include/swift/ABI/MetadataValues.h

@@ -2511,6 +2511,32 @@ inline int descendingPriorityOrder(JobPriority lhs,
   return (lhs == rhs ? 0 : lhs > rhs ? -1 : 1);
 }
 
+enum { PriorityBucketCount = 5 };
+
+inline int getPriorityBucketIndex(JobPriority priority) {
+  // Any unknown priorities will be rounded up to a known one.
+  // Priorities higher than UserInteractive are clamped to UserInteractive.
+  // Jobs of unknown priorities will end up in the same bucket as jobs of a
+  // corresponding known priority. Within the bucket they will be sorted in
+  // FIFO order.
+  if (priority > JobPriority::UserInitiated) {
+    // UserInteractive and higher
+    return 0;
+  } else if (priority > JobPriority::Default) {
+    // UserInitiated
+    return 1;
+  } else if (priority > JobPriority::Utility) {
+    // Default
+    return 2;
+  } else if (priority > JobPriority::Background) {
+    // Utility
+    return 3;
+  } else {
+    // Background and lower
+    return 4;
+  }
+}
+
 inline JobPriority withUserInteractivePriorityDowngrade(JobPriority priority) {
   return (priority == JobPriority::UserInteractive) ? JobPriority::UserInitiated
                                                     : priority;

include/swift/ABI/TaskLocal.h

@@ -129,11 +129,11 @@ class TaskLocal {
       return reinterpret_cast<Item *>(next & ~statusMask);
     }
 
-    void relinkNext(Item* nextOverride) {
+    void relinkTaskGroupLocalHeadToSafeNext(Item* nextOverride) {
       assert(!getNext() &&
                "Can only relink task local item that was not pointing at anything yet");
-      assert(nextOverride->isNextLinkPointer() ||
-             nextOverride->isParentPointer() &&
+      assert((nextOverride->isNextLinkPointer() ||
+              nextOverride->isParentPointer()) &&
                  "Currently relinking is only done within a task group to "
                  "avoid within-taskgroup next pointers; attempted to point at "
                  "task local declared within task group body though!");
@@ -230,6 +230,10 @@ class TaskLocal {
 
   public:
 
+    /// Get the "current" task local storage from either the passed in
+    /// task, or fall back to the *thread* local stored storage.
+    static Storage* getCurrent(AsyncTask *task);
+
     void initializeLinkParent(AsyncTask *task, AsyncTask *parent);
 
     void pushValue(AsyncTask *task,
@@ -258,7 +262,9 @@ class TaskLocal {
     /// "pop" of the `B` value - it was spawned from a scope where only B was observable.
     void copyTo(AsyncTask *target);
 
-    void copyToOnlyOnlyFromCurrent(AsyncTask *target);
+    // FIXME(concurrency): We currently copy from "all" task groups we encounter
+    // however in practice we only
+    void copyToOnlyOnlyFromCurrentGroup(AsyncTask *target);
 
     /// Destroy and deallocate all items stored by this specific task.
     ///

include/swift/AST/ASTContext.h

@@ -47,6 +47,7 @@
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/VirtualOutputBackend.h"
 #include <functional>
 #include <memory>
@@ -409,9 +410,17 @@ class ASTContext final {
   /// Cache of module names that fail the 'canImport' test in this context.
   mutable llvm::StringSet<> FailedModuleImportNames;
 
+  /// Versions of the modules found during versioned canImport checks. 
+  struct ImportedModuleVersionInfo {
+    llvm::VersionTuple Version;
+    llvm::VersionTuple UnderlyingVersion;
+  };
+
   /// Cache of module names that passed the 'canImport' test. This cannot be
-  /// mutable since it needs to be queried for dependency discovery.
-  llvm::StringSet<> SucceededModuleImportNames;
+  /// mutable since it needs to be queried for dependency discovery. Keep sorted
+  /// so caller of `forEachCanImportVersionCheck` can expect deterministic
+  /// ordering.
+  std::map<std::string, ImportedModuleVersionInfo> CanImportModuleVersions;
 
   /// Set if a `-module-alias` was passed. Used to store mapping between module aliases and
   /// their corresponding real names, and vice versa for a reverse lookup, which is needed to check
@@ -1102,7 +1111,12 @@ class ASTContext final {
   /// module is loaded in full.
   bool canImportModuleImpl(ImportPath::Module ModulePath,
                            llvm::VersionTuple version, bool underlyingVersion,
-                           bool updateFailingList) const;
+                           bool updateFailingList,
+                           llvm::VersionTuple &foundVersion) const;
+
+  /// Add successful canImport modules.
+  void addSucceededCanImportModule(StringRef moduleName, bool underlyingVersion,
+                                   const llvm::VersionTuple &versionInfo);
 
 public:
   namelookup::ImportCache &getImportCache() const;
@@ -1144,10 +1158,10 @@ class ASTContext final {
                         llvm::VersionTuple version = llvm::VersionTuple(),
                         bool underlyingVersion = false) const;
 
-  /// \returns a set of names from all successfully canImport module checks.
-  const llvm::StringSet<> &getSuccessfulCanImportCheckNames() const {
-    return SucceededModuleImportNames;
-  }
+  /// Callback on each successful imported.
+  void forEachCanImportVersionCheck(
+      std::function<void(StringRef, const llvm::VersionTuple &,
+                         const llvm::VersionTuple &)>) const;
 
   /// \returns a module with a given name that was already loaded.  If the
   /// module was not loaded, returns nullptr.