PerformanceInliner: enable generic inlining of co-routines

Co-routines are so expensive (e.g. Array.subscript.read) that it makes sense to enable generic inlining of co-routines.
This will speed up array iteration (e.g. for elem in array { }) in a generic context significantly.
Another example is ManagedBuffer.header.read, which gets much faster.
In both cases, the speedup is mainly because there is no malloc happening anymore.

https://bugs.swift.org/browse/SR-11231
rdar://problem/53777612

Author: eeckstein

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -262,8 +262,6 @@ bool SILPerformanceInliner::isProfitableToInline(
   assert(Callee);
   bool IsGeneric = AI.hasSubstitutions();
 
-  assert(EnableSILInliningOfGenerics || !IsGeneric);
-
   // Start with a base benefit.
   int BaseBenefit = RemovedCallBenefit;
 
@@ -555,17 +553,26 @@ static Optional<bool> shouldInlineGeneric(FullApplySite AI) {
   if (Callee->getInlineStrategy() == AlwaysInline || Callee->isTransparent())
     return true;
 
-  // All other generic functions should not be inlined if this kind of inlining
-  // is disabled.
-  if (!EnableSILInliningOfGenerics)
-    return false;
-
   // If all substitutions are concrete, then there is no need to perform the
   // generic inlining. Let the generic specializer create a specialized
   // function and then decide if it is beneficial to inline it.
   if (!AI.getSubstitutionMap().hasArchetypes())
     return false;
 
+  if (Callee->getLoweredFunctionType()->getCoroutineKind() !=
+      SILCoroutineKind::None) {
+    // Co-routines are so expensive (e.g. Array.subscript.read) that we always
+    // enable inlining them in a generic context. Though the final inlining
+    // decision is done by the usual heuristics. Therefore we return None and
+    // not true.
+    return None;
+  }
+
+  // All other generic functions should not be inlined if this kind of inlining
+  // is disabled.
+  if (!EnableSILInliningOfGenerics)
+    return false;
+
   // It is not clear yet if this function should be decided or not.
   return None;
 }

lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp

@@ -767,20 +767,16 @@ SILFunction *swift::getEligibleFunction(FullApplySite AI,
     return nullptr;
   }
 
-  if (!EnableSILInliningOfGenerics && AI.hasSubstitutions()) {
-    // Inlining of generics is not allowed unless it is an @inline(__always)
-    // or transparent function.
-    if (Callee->getInlineStrategy() != AlwaysInline && !Callee->isTransparent())
-      return nullptr;
-  }
-
   // We cannot inline function with layout constraints on its generic types
   // if the corresponding substitution type does not have the same constraints.
   // The reason for this restriction is that we'd need to be able to express
   // in SIL something like casting a value of generic type T into a value of
   // generic type T: _LayoutConstraint, which is impossible currently.
-  if (EnableSILInliningOfGenerics && AI.hasSubstitutions()) {
-    if (!isCallerAndCalleeLayoutConstraintsCompatible(AI))
+  if (AI.hasSubstitutions()) {
+    if (!isCallerAndCalleeLayoutConstraintsCompatible(AI) &&
+        // TODO: revisit why we can make an exception for inline-always
+        // functions. Some tests depend on it.
+        Callee->getInlineStrategy() != AlwaysInline && !Callee->isTransparent())
       return nullptr;
   }
 

test/SILOptimizer/inline_generic_coroutines.swift

@@ -0,0 +1,34 @@
+// RUN: %target-swift-frontend -parse-as-library -O -emit-sil  %s | %FileCheck %s
+// REQUIRES: swift_stdlib_no_asserts,optimized_stdlib
+
+@inline(never)
+func useit<T>(_ t: T) {
+  print(t)
+}
+
+// Check that we inline the Array.subscript.read coroutine
+
+// CHECK-LABEL: sil @{{.*}}testit
+// CHECK-NOT:     begin_apply
+// CHECK-NOT:     end_apply
+// CHECK:       } // end sil function {{.*}}testit
+public func testit<T>(_ a: [T]) {
+  for t in a {
+    useit(t)
+  }
+}
+
+// Check that we inline the ManagedBufferPointer.header.read coroutine
+
+public final class MyBuffer<Element> {
+    typealias Manager = ManagedBufferPointer<Int, Element>
+
+    // CHECK-LABEL: sil @{{.*}}MyBuffer{{.*}}countSivg
+    // CHECK-NOT:     begin_apply
+    // CHECK-NOT:     end_apply
+    // CHECK:       } // end sil function {{.*}}MyBuffer{{.*}}countSivg
+    public var count: Int {
+        return Manager(unsafeBufferObject: self).header
+    }
+}
+