Add a new -assume-single-threaded option

This is a hidden option. It should be used like: -Xllvm -assume-single-threaded

When this function is provided, the compiler assumes that the code will be executed in the single threaded mode. It then performs certain optimizations that can benefit from it, e.g. it  marks as non-atomic all reference counting instructions in the user code being compiled.

Author: swiftix

include/swift/SILOptimizer/PassManager/Passes.def

@@ -40,6 +40,8 @@ PASS(ArrayCountPropagation, "array-count-propagation",
      "Propagate the count of arrays")
 PASS(ArrayElementPropagation, "array-element-propagation",
      "Propagate the value of array elements")
+PASS(AssumeSingleThreaded, "sil-assume-single-threaded",
+     "Assume that code will be executed in a single-threaded environment")
 PASS(BasicInstructionPropertyDumper, "basic-instruction-property-dump",
      "Dump MemBehavior and ReleaseBehavior results from calling "
      "SILInstruction::{getMemoryBehavior,getReleasingBehavior}()"

lib/SILOptimizer/PassManager/Passes.cpp

@@ -412,6 +412,9 @@ void swift::runSILOptimizationPasses(SILModule &Module) {
   // after FSO.
   PM.addLateReleaseHoisting();
 
+  // Has only an effect if the -assume-single-thread option is specified.
+  PM.addAssumeSingleThreaded();
+
   PM.runOneIteration();
 
   PM.resetAndRemoveTransformations();
@@ -452,6 +455,9 @@ void swift::runSILPassesForOnone(SILModule &Module) {
   // eventually remove unused declarations.
   PM.addExternalDefsToDecls();
 
+  // Has only an effect if the -assume-single-thread option is specified.
+  PM.addAssumeSingleThreaded();
+
   // Has only an effect if the -gsil option is specified.
   PM.addSILDebugInfoGenerator();
 

lib/SILOptimizer/Transforms/AssumeSingleThreaded.cpp

@@ -0,0 +1,57 @@
+//===--- AssumeSingleThreaded.cpp - Assume single-threaded executution  ---===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 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-thread 
+//
+// Convert all reference counting operations into non-atomic ones.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILModule.h"
+#include "swift/SILOptimizer/Utils/Local.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/CommandLine.h"
+
+using namespace swift;
+
+llvm::cl::opt<bool> AssumeSingleThreadedFlag(
+    "assume-single-threaded", llvm::cl::init(false),
+    llvm::cl::Hidden,
+    llvm::cl::desc(
+        "Assume that code will be executed in a single-threaded environment"));
+
+namespace {
+class AssumeSingleThreaded : public swift::SILFunctionTransform {
+  /// The entry point to the transformation.
+  void run() override {
+    if (!AssumeSingleThreadedFlag)
+      return;
+    for (auto &BB : *getFunction()) {
+      for (auto &I : BB) {
+        if (auto RCInst = dyn_cast<RefCountingInst>(&I))
+          RCInst->setNonAtomic();
+      }
+    }
+    invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+  }
+
+  StringRef getName() override { return "Assume single threaded"; }
+};
+} // end anonymous namespace
+
+
+SILTransform *swift::createAssumeSingleThreaded() {
+  return new AssumeSingleThreaded();
+}

lib/SILOptimizer/Transforms/CMakeLists.txt

@@ -3,6 +3,7 @@ set(TRANSFORMS_SOURCES
   Transforms/AllocBoxToStack.cpp
   Transforms/ArrayCountPropagation.cpp
   Transforms/ArrayElementValuePropagation.cpp
+  Transforms/AssumeSingleThreaded.cpp
   Transforms/CSE.cpp
   Transforms/ConditionForwarding.cpp
   Transforms/CopyForwarding.cpp

test/SILOptimizer/nonatomic_reference_counting.sil

@@ -0,0 +1,51 @@
+// RUN: %target-swift-frontend -emit-sil -assume-parsing-unqualified-ownership-sil %s -Xllvm -assume-single-threaded | %FileCheck %s
+// RUN: %target-swift-frontend -emit-sil -assume-parsing-unqualified-ownership-sil %s -O -Xllvm -assume-single-threaded | %FileCheck %s
+
+// Check that all reference counting instructions are converted to [nonatomic]
+// if -assume-single-threaded is used.
+
+sil_stage canonical
+
+import Builtin
+import Swift
+import SwiftShims
+
+public class C {
+  deinit
+  init()
+}
+
+
+// CHECK-LABEL: sil{{.*}}@test_atomic_to_nonatomic_retain
+// CHECK: strong_retain [nonatomic]
+// CHECK: return
+sil @test_atomic_to_nonatomic_retain: $@convention(thin) () -> @owned C {
+bb0:
+  %1 = alloc_ref $C
+  strong_retain %1 : $C
+  return %1 : $C
+}
+
+// CHECK-LABEL: sil{{.*}}@test_atomic_to_nonatomic_release
+// CHECK: strong_release [nonatomic]
+// CHECK: return
+sil @test_atomic_to_nonatomic_release: $@convention(thin) (C) -> C {
+bb0(%0 : $C):
+  strong_release %0 : $C
+  return %0 : $C
+}
+
+
+
+// C.__deallocating_deinit
+sil @_TFC28nonatomic_reference_counting1CD : $@convention(method) (@owned C) -> () {
+bb0(%0 : $C):
+  dealloc_ref %0 : $C
+  %4 = tuple ()
+  return %4 : $()
+}
+
+sil_vtable C {
+  #C.deinit!deallocator: _TFC28nonatomic_reference_counting1CD  // C.__deallocating_deinit
+}
+