Merge branch 'master' of github.com:apple/swift into ast-nondiff

Author: Marc Rasi

README.md

@@ -155,26 +155,26 @@ First, make sure that you're in the swift directory:
 
 To build using Ninja, run:
 
-    swift/utils/build-script --release-debuginfo
+    utils/build-script --release-debuginfo
 
 When developing Swift, it helps to build what you're working on in a debug
 configuration while building the rest of the project with optimizations. Below
 are some examples of using debug variants:
 
-    swift/utils/build-script --release-debuginfo --debug-swift # Swift frontend built in debug
-    swift/utils/build-script --release-debuginfo --debug-swift-stdlib # Standard library built in debug
-    swift/utils/build-script --release-debuginfo --debug-swift --force-optimized-typechecker # Swift frontend sans type checker built in debug
+    utils/build-script --release-debuginfo --debug-swift # Swift frontend built in debug
+    utils/build-script --release-debuginfo --debug-swift-stdlib # Standard library built in debug
+    utils/build-script --release-debuginfo --debug-swift --force-optimized-typechecker # Swift frontend sans type checker built in debug
 
 Limiting the amount of debug code in the compiler has a very large impact on
 Swift compile times, and in turn the test execution time. If you want to build
 the entire project in debug, you can run:
 
-    swift/utils/build-script --debug
+    utils/build-script --debug
 
 For documentation of all available arguments, as well as additional usage
 information, see the inline help:
 
-    swift/utils/build-script -h
+    utils/build-script -h
 
 #### Xcode
 

benchmark/single-source/NSStringConversion.swift

@@ -17,6 +17,7 @@ import TestsUtils
 import Foundation
 
 fileprivate var test:NSString = ""
+fileprivate var mutableTest = ""
 
 public let NSStringConversion = [
   BenchmarkInfo(name: "NSStringConversion",
@@ -65,7 +66,44 @@ public let NSStringConversion = [
   BenchmarkInfo(name: "NSStringConversion.Rebridge.LongUTF8",
                 runFunction: run_NSStringConversion_longNonASCII_rebridge,
                 tags: [.validation, .api, .String, .bridging],
-                setUpFunction: { test = NSString(cString: "Thë qüick bröwn föx jumps over the lazy dög", encoding: String.Encoding.utf8.rawValue)! })]
+                setUpFunction: { test = NSString(cString: "Thë qüick bröwn föx jumps over the lazy dög", encoding: String.Encoding.utf8.rawValue)! } ),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.UTF8",
+                runFunction: run_NSStringConversion_nonASCIIMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "tëst" }),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Medium",
+                runFunction: run_NSStringConversion_mediumMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "aaaaaaaaaaaaaaa" } ),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Long",
+                runFunction: run_NSStringConversion_longMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "The quick brown fox jumps over the lazy dog" } ),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.LongUTF8",
+                runFunction: run_NSStringConversion_longNonASCIIMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "Thë qüick bröwn föx jumps over the lazy dög" } ),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Rebridge",
+                runFunction: run_NSStringConversion_rebridgeMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "test" }),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Rebridge.UTF8",
+                runFunction: run_NSStringConversion_nonASCII_rebridgeMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "tëst" }),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Rebridge.Medium",
+                runFunction: run_NSStringConversion_medium_rebridgeMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "aaaaaaaaaaaaaaa" } ),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Rebridge.Long",
+                runFunction: run_NSStringConversion_long_rebridgeMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "The quick brown fox jumps over the lazy dog" } ),
+  BenchmarkInfo(name: "NSStringConversion.MutableCopy.Rebridge.LongUTF8",
+                runFunction: run_NSStringConversion_longNonASCII_rebridgeMutable,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: { mutableTest = "Thë qüick bröwn föx jumps over the lazy dög" } )
+]
 
 public func run_NSStringConversion(_ N: Int) {
 let test:NSString = NSString(cString: "test", encoding: String.Encoding.ascii.rawValue)!
@@ -103,6 +141,31 @@ public func run_NSStringConversion_longNonASCII(_ N: Int) {
   innerLoop(test, N, 300)
 }
 
+fileprivate func innerMutableLoop(_ str: String, _ N: Int, _ scale: Int = 5000) {
+  for _ in 1...N * scale {
+    let copy = (str as NSString).mutableCopy() as! NSMutableString
+    for char in (identity(copy) as String).utf8 {
+      blackHole(char)
+    }
+  }
+}
+
+public func run_NSStringConversion_nonASCIIMutable(_ N: Int) {
+  innerMutableLoop(mutableTest, N, 500)
+}
+
+public func run_NSStringConversion_mediumMutable(_ N: Int) {
+  innerMutableLoop(mutableTest, N, 500)
+}
+
+public func run_NSStringConversion_longMutable(_ N: Int) {
+  innerMutableLoop(mutableTest, N, 250)
+}
+
+public func run_NSStringConversion_longNonASCIIMutable(_ N: Int) {
+  innerMutableLoop(mutableTest, N, 150)
+}
+
 fileprivate func innerRebridge(_ str: NSString, _ N: Int, _ scale: Int = 5000) {
   for _ in 1...N * scale {
     let bridged = identity(str) as String
@@ -135,4 +198,33 @@ public func run_NSStringConversion_longNonASCII_rebridge(_ N: Int) {
   innerRebridge(test, N, 300)
 }
 
+fileprivate func innerMutableRebridge(_ str: String, _ N: Int, _ scale: Int = 5000) {
+  for _ in 1...N * scale {
+    let copy = (str as NSString).mutableCopy() as! NSMutableString
+    let bridged = identity(copy) as String
+    blackHole(bridged)
+    blackHole(bridged as NSString)
+  }
+}
+
+public func run_NSStringConversion_rebridgeMutable(_ N: Int) {
+  innerMutableRebridge(mutableTest, N, 1000)
+}
+
+public func run_NSStringConversion_nonASCII_rebridgeMutable(_ N: Int) {
+  innerMutableRebridge(mutableTest, N, 500)
+}
+
+public func run_NSStringConversion_medium_rebridgeMutable(_ N: Int) {
+  innerMutableRebridge(mutableTest, N, 500)
+}
+
+public func run_NSStringConversion_long_rebridgeMutable(_ N: Int) {
+  innerMutableRebridge(mutableTest, N, 500)
+}
+
+public func run_NSStringConversion_longNonASCII_rebridgeMutable(_ N: Int) {
+  innerMutableRebridge(mutableTest, N, 300)
+}
+
 #endif

docs/HighLevelSILOptimizations.rst

@@ -135,7 +135,7 @@ Array<Element>, ContiguousArray<Element>, and ArraySlice<Element>
 data-structures.
 
 We consider the array state to consist of a set of disjoint elements
-and a storage descriptor that encapsulates nonelement data such as the
+and a storage descriptor that encapsulates non-element data such as the
 element count and capacity. Operations that semantically write state
 are always *control dependent*. A control dependent operation is one
 that may only be executed on the control flow paths in which the