Merge pull request #40781 from apple/maxd/assume-single-threaded

libswift: reimplement `AssumeSingleThreaded` pass

I don't think that `AssumeSingleThreaded` is widely used, certainly doesn't look like a mandatory pass, and it seemed trivial enough for a first try of rewriting passes in Swift.

Author: MaxDesiatov

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AssumeSingleThreaded.swift

@@ -0,0 +1,40 @@
+//===--- AssumeSingleThreaded.swift - Assume single-threaded execution ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Assume that user code is single-threaded.
+//
+// Convert all reference counting operations into non-atomic ones.
+//
+// To get rid of most atomic reference counting operations, the standard
+// library should be compiled in this mode as well .
+//
+// This pass affects only reference counting operations resulting from SIL
+// instructions. It wouldn't affect places in the runtime C++ code which
+// hard-code calls to retain/release. We could take advantage of the Instruments
+// instrumentation stubs to redirect calls from the runtime if it was
+// significant, or else just build a single-threaded variant of the runtime.
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+let assumeSingleThreadedPass = FunctionPass(
+  name: "sil-assume-single-threaded", { function, context in
+    for block in function.blocks {
+      for inst in block.instructions {
+        guard let rcInst = inst as? RefCountingInst else { continue }
+
+        context.setAtomicity(of: rcInst, isAtomic: false)
+      }
+    }
+  }
+)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -7,6 +7,7 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
+  AssumeSingleThreaded.swift
   SILPrinter.swift
   MergeCondFails.swift
 )

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -50,4 +50,5 @@ private func registerSwiftPasses() {
   registerPass(simplifyGlobalValuePass, { simplifyGlobalValuePass.run($0) })
   registerPass(simplifyStrongRetainPass, { simplifyStrongRetainPass.run($0) })
   registerPass(simplifyStrongReleasePass, { simplifyStrongReleasePass.run($0) })
+  registerPass(assumeSingleThreadedPass, { assumeSingleThreadedPass.run($0) })
 }

SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift

@@ -78,6 +78,12 @@ struct PassContext {
 
     SILInstruction_setOperand(instruction.bridged, index, value.bridged)
   }
+
+  func setAtomicity(of instruction: RefCountingInst, isAtomic: Bool) {
+    PassContext_notifyChanges(passContext, instructionsChanged)
+
+    RefCountingInst_setIsAtomic(instruction.bridged, isAtomic)
+  }
 }
 
 struct FunctionPass {

include/swift/SIL/SILBridging.h

@@ -233,6 +233,7 @@ BridgedBasicBlock BranchInst_getTargetBlock(BridgedInstruction bi);
 SwiftInt SwitchEnumInst_getNumCases(BridgedInstruction se);
 SwiftInt SwitchEnumInst_getCaseIndex(BridgedInstruction se, SwiftInt idx);
 SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store);
+void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic);
 
 BridgedInstruction SILBuilder_createBuiltinBinaryFunction(
           BridgedInstruction insertionPoint,

include/swift/SILOptimizer/PassManager/Passes.def

@@ -131,7 +131,7 @@ PASS(ArrayCountPropagation, "array-count-propagation",
      "Array Count Propagation")
 PASS(ArrayElementPropagation, "array-element-propagation",
      "Array Element Propagation")
-PASS(AssumeSingleThreaded, "sil-assume-single-threaded",
+SWIFT_FUNCTION_PASS_WITH_LEGACY(AssumeSingleThreaded, "sil-assume-single-threaded",
      "Assume Single-Threaded Environment")
 PASS(BasicInstructionPropertyDumper, "basic-instruction-property-dump",
      "Print SIL Instruction MemBehavior and ReleaseBehavior Information")

lib/SIL/Utils/SILBridging.cpp

@@ -483,6 +483,11 @@ SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store) {
   return (SwiftInt)castToInst<StoreInst>(store)->getOwnershipQualifier();
 }
 
+void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic) {
+  castToInst<RefCountingInst>(rc)->setAtomicity(
+      isAtomic ? RefCountingInst::Atomicity::Atomic
+               : RefCountingInst::Atomicity::NonAtomic);
+}
 
 //===----------------------------------------------------------------------===//
 //                                SILBuilder

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -766,7 +766,9 @@ static void addLastChanceOptPassPipeline(SILPassPipelinePlan &P) {
 #endif
 
   // Only has an effect if the -assume-single-thread option is specified.
-  P.addAssumeSingleThreaded();
+  if (P.getOptions().AssumeSingleThreaded) {
+    P.addAssumeSingleThreaded();
+  }
 
   // Emits remarks on all functions with @_assemblyVision attribute.
   P.addAssemblyVisionRemarkGenerator();
@@ -925,7 +927,9 @@ SILPassPipelinePlan::getOnonePassPipeline(const SILOptions &Options) {
   P.addUsePrespecialized();
 
   // Has only an effect if the -assume-single-thread option is specified.
-  P.addAssumeSingleThreaded();
+  if (P.getOptions().AssumeSingleThreaded) {
+    P.addAssumeSingleThreaded();
+  }
 
   // Create pre-specializations.
   P.addOnonePrespecializations();

lib/SILOptimizer/Transforms/AssumeSingleThreaded.cpp

@@ -15,7 +15,7 @@
 // Convert all reference counting operations into non-atomic ones.
 //
 // To get read of most atomic reference counting operations, the standard
-// library should be compiled in this mode as well 
+// library should be compiled in this mode as well
 //
 // This pass affects only reference counting operations resulting from SIL
 // instructions. It wouldn't affect places in the runtime C++ code which
@@ -49,11 +49,9 @@ class AssumeSingleThreaded : public swift::SILFunctionTransform {
     }
     invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
   }
-
 };
 } // end anonymous namespace
 
-
-SILTransform *swift::createAssumeSingleThreaded() {
+SILTransform *swift::createLegacyAssumeSingleThreaded() {
   return new AssumeSingleThreaded();
 }

test/sil-passpipeline-dump/basic.test-sh

@@ -8,6 +8,5 @@
 // CHECK: passes:          [ "serialize-sil", "ownership-model-eliminator" ]
 // CHECK: ---
 // CHECK: name:            Rest of Onone
-// CHECK: passes:          [ "use-prespecialized", "sil-assume-single-threaded",
-// CHECK:                    "sil-debuginfo-gen" ]
+// CHECK: passes:          [ "use-prespecialized", "onone-prespecializer", "sil-debuginfo-gen" ]
 // CHECK: ...