---

yaml
---
r: 286327
b: refs/heads/master-next
c: d6f44cc
h: refs/heads/master
i:
  286325: 002ef6c
  286323: 922e35a
  286319: 55e486c

Author: lorentey

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: a67ffadd758dfc7a0f10a8afde063b8864663208
-refs/heads/master-next: 1dbb4830c5ca465b4ee2de334f78f96db31f41b6
+refs/heads/master-next: d6f44ccdd8cd92daa48a3829ac6e961e31357926
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/CMakeLists.txt

@@ -598,7 +598,7 @@ else()
   # FIXME: Only matches v6l/v7l - by far the most common variants
   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv6l")
     set(SWIFT_HOST_VARIANT_ARCH_default "armv6")
-  elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv7l")
+  elseif("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "armv7l|armv7-a")
     set(SWIFT_HOST_VARIANT_ARCH_default "armv7")
   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "AMD64")
     set(SWIFT_HOST_VARIANT_ARCH_default "x86_64")
@@ -998,17 +998,17 @@ if(SWIFT_NEED_EXPLICIT_LIBDISPATCH)
   else()
     set(SOURCEKIT_RUNTIME_DIR lib)
   endif()
-  swift_install_in_component(sourcekit-inproc
-                             FILES
+  swift_install_in_component(FILES
                                $<TARGET_FILE:dispatch>
                                $<TARGET_FILE:BlocksRuntime>
-                             DESTINATION ${SOURCEKIT_RUNTIME_DIR})
+                             DESTINATION ${SOURCEKIT_RUNTIME_DIR}
+                             COMPONENT sourcekit-inproc)
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
-    swift_install_in_component(sourcekit-inproc
-                               FILES
+    swift_install_in_component(FILES
                                  $<TARGET_LINKER_FILE:dispatch>
                                  $<TARGET_LINKER_FILE:BlocksRuntime>
-                               DESTINATION lib)
+                               DESTINATION lib
+                               COMPONENT sourcekit-inproc)
   endif()
 
 
@@ -1083,9 +1083,9 @@ endif()
 
 add_subdirectory(cmake/modules)
 
-swift_install_in_component(license
-  FILES "LICENSE.txt"
-  DESTINATION "share/swift")
+swift_install_in_component(FILES "LICENSE.txt"
+                           DESTINATION "share/swift"
+                           COMPONENT license)
 
 # Add a documentation target so that documentation shows up in the
 # Xcode project.

branches/master-next/apinotes/CMakeLists.txt

@@ -31,7 +31,7 @@ add_custom_target("copy_apinotes"
 # This is treated as an OPTIONAL target because if we don't build the SDK
 # overlay, the files will be missing anyway. It also allows us to build
 # single overlays without installing the API notes.
-swift_install_in_component(sdk-overlay
-    DIRECTORY "${output_dir}"
-    DESTINATION "lib/swift/"
-    OPTIONAL)
+swift_install_in_component(DIRECTORY "${output_dir}"
+                           DESTINATION "lib/swift/"
+                           COMPONENT sdk-overlay
+                           OPTIONAL)

branches/master-next/benchmark/single-source/Breadcrumbs.swift

@@ -45,23 +45,6 @@ extension String {
   }
 }
 
-let seed = 0x12345678
-
-/// A linear congruential PRNG.
-struct LCRNG: RandomNumberGenerator {
-  private var state: UInt64
-
-  init(seed: Int) {
-    state = UInt64(truncatingIfNeeded: seed)
-    for _ in 0..<10 { _ = next() }
-  }
-
-  mutating func next() -> UInt64 {
-    state = 2862933555777941757 &* state &+ 3037000493
-    return state
-  }
-}
-
 extension Collection {
   /// Returns a randomly ordered array of random non-overlapping index ranges
   /// that cover this collection entirely.
@@ -254,7 +237,7 @@ class UTF16ToIdx: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     let range = 0 ..< inputString.utf16.count
     inputOffsets = Array(range.shuffled(using: &rng).prefix(count))
   }
@@ -286,7 +269,7 @@ class IdxToUTF16: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = Array(inputString.indices.shuffled(using: &rng).prefix(count))
   }
 
@@ -318,7 +301,7 @@ class UTF16ToIdxRange: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputOffsets = (
       0 ..< inputString.utf16.count
     ).randomIndexRanges(count: count, using: &rng)
@@ -352,7 +335,7 @@ class IdxToUTF16Range: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = self.inputString.randomIndexRanges(count: count, using: &rng)
   }
 
@@ -384,7 +367,7 @@ class CopyUTF16CodeUnits: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = (
       0 ..< inputString.utf16.count
     ).randomIndexRanges(count: count, using: &rng)
@@ -425,7 +408,7 @@ class MutatedUTF16ToIdx: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var generator = LCRNG(seed: seed)
+    var generator = SplitMix64(seed: 42)
     let range = 0 ..< inputString.utf16.count
     inputOffsets = Array(range.shuffled(using: &generator).prefix(count))
   }
@@ -469,7 +452,7 @@ class MutatedIdxToUTF16: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = Array(inputString.indices.shuffled(using: &rng).prefix(count))
   }
 

branches/master-next/benchmark/single-source/BucketSort.swift

@@ -1,4 +1,4 @@
-//===--- BucketSort.swift ----------------------------------------------------===//
+//===--- BucketSort.swift -------------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -9,21 +9,21 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-// Adapted from the original implementation: 
+// This benchmark demonstrates the benefits of ExistentialSpecializer
+// optimization pass. It's a generic version of the classic BucketSort algorithm
+// adapted from an original implementation from the Swift Algorithm Club.
+// See https://en.wikipedia.org/wiki/Bucket_sort and
 // https://github.com/raywenderlich/swift-algorithm-club/tree/master/Bucket%20Sort
-// Issue: https://github.com/raywenderlich/swift-algorithm-club/issues/863
-
-// This benchmark implements the classical BucketSort algorithm described at
-// https://en.wikipedia.org/wiki/Bucket_sort. The implementation allows for an
-// array of generic type of "SortableItem" to be sorted. Unfortunately,  if
-// ``sortingAlgo'' type is not known for the callsite in line 84, then the 
-// ``sort'' method can not be specialized to integer array sorting, which will 
-// lead to a huge performance loss. Since SortingAlgorithm and InsertionSort are 
-// declared to be ``public'' and that lines 83-85 can not be inlined in
-// BucketSortImpl (due to inlining heuristic limitations), today swift 
-// compiler (without ExistentialSpecializer) can not achieve this feat.  With 
-// ExistentialSpecializer which enables generic specialization recursively in a
-// call chain, we are able to specialize line 84 for InsertionSort on integers.
+//
+// It sorts an array of generic `SortableItem`s. If the type of `sortingAlgo`
+// is not known to the call site at line 90, the `sort` method can not be
+// specialized to integer array sorting, which will lead to a huge performance
+// loss. Since `SortingAlgorithm` and `InsertionSort` are declared to be
+// `public` and the lines 89-91 can not be inlined in `bucketSort` (due to
+// inlining heuristic limitations), compiler without ExistentialSpecializer
+// optimization can not achieve this feat. With ExistentialSpecializer which
+// enables generic specialization recursively in a call chain, we're able to
+// specialize line 90 for `InsertionSort` on integers.
 
 import TestsUtils
 import Foundation
@@ -32,21 +32,25 @@ public let BucketSort = BenchmarkInfo(
   name: "BucketSort",
   runFunction: run_BucketSort,
   tags: [.validation, .algorithm],
-  setUpFunction: { buildWorkload() },
-  legacyFactor: 10)
+  setUpFunction: { blackHole(buckets) }
+)
 
 public protocol IntegerConvertible {
     func convertToInt() -> Int
 }
+
 extension Int: IntegerConvertible, SortableItem {
     public func convertToInt() -> Int {
         return self
     }
 }
+
 public protocol SortableItem: IntegerConvertible, Comparable { }
+
 public protocol SortingAlgorithm {
     func sort<T: SortableItem>(_ items: [T]) -> [T]
 }
+
 public struct InsertionSort: SortingAlgorithm {
     public func sort<T: SortableItem>(_ items: [T]) -> [T] {
         var sortedItems = items
@@ -62,12 +66,14 @@ public struct InsertionSort: SortingAlgorithm {
         return sortedItems
     }
 }
+
 func distribute<T>(_ item: T, bucketArray: inout [Bucket<T>]) {
   let val = item.convertToInt()
   let capacity = bucketArray.first!.capacity
   let index = val / capacity
   bucketArray[index].add(item)
 }
+
 struct Bucket<T: SortableItem> {
   var items: [T]
   let capacity: Int
@@ -84,7 +90,10 @@ struct Bucket<T: SortableItem> {
     return sortingAlgo.sort(items)
   }
 }
-func BucketSortImpl<T>(_ items: [T], sortingAlgorithm: SortingAlgorithm, bucketArray: [Bucket<T>]) -> [T] {
+
+func bucketSort<T>(
+  _ items: [T], sortingAlgorithm: SortingAlgorithm, bucketArray: [Bucket<T>]
+) -> [T] {
   var copyBucketArray = bucketArray
   for item in items {
     distribute(item, bucketArray: &copyBucketArray)
@@ -95,45 +104,28 @@ func BucketSortImpl<T>(_ items: [T], sortingAlgorithm: SortingAlgorithm, bucketA
   }
   return sortedArray
 }
-func isArraySorted(_ arr: [Int]) -> Bool {
-  var idx = 0
-  while idx < (arr.count - 1) {
-    if arr[idx] > arr[idx+1] {
-       return false
-    }
-    idx += 1
-  }
-  return true
+
+func isAscending(_ a: [Int]) -> Bool {
+  return zip(a, a.dropFirst()).allSatisfy(<=)
 }
-let NUMITEMS = 2500
-let MAXBUCKETSIZE = 1000
-let NUMBUCKETS: Int = 10
+
 let items: [Int] = {
-  var array: [Int]? = [Int]()
-  for _ in 0..<NUMITEMS {
-    array!.append(Int.random(in: 0..<MAXBUCKETSIZE))
-  }
-  return array!
+  var g = SplitMix64(seed: 42)
+  return (0..<10_000).map {_ in Int.random(in: 0..<1000, using: &g) }
 }()
 
 let buckets: [Bucket<Int>] = {
-  let val = (items.max()?.convertToInt())! + 1
-  let maxCapacity = Int( ceil( Double(val) / Double(NUMBUCKETS)))
-  var bucketArray = [Bucket<Int>]()
-  for _ in 0..<NUMBUCKETS {
-    bucketArray.append(Bucket<Int>(capacity: maxCapacity))
-  }
-  return bucketArray
+  let bucketCount = 10
+  let maxValue = items.max()!.convertToInt()
+  let maxCapacity = Int(ceil(Double(maxValue + 1) / Double(bucketCount)))
+  return (0..<bucketCount).map { _ in Bucket<Int>(capacity: maxCapacity) }
 }()
+
 @inline(never)
 func run_BucketSort(_ N : Int) {
   for _ in 0..<N {
-    let sortedArray = BucketSortImpl(items, sortingAlgorithm: InsertionSort(), bucketArray: buckets)
-    CheckResults(isArraySorted(sortedArray))
+    let sortedArray = bucketSort(
+      items, sortingAlgorithm: InsertionSort(), bucketArray: buckets)
+    CheckResults(isAscending(sortedArray))
   }
 }
-@inline(never)
-func buildWorkload() {
-  blackHole(items)
-  blackHole(buckets)
-}

branches/master-next/benchmark/single-source/ObjectiveCBridging.swift

@@ -73,6 +73,9 @@ public let ObjectiveCBridging = [
   BenchmarkInfo(name: "ObjectiveCBridgeFromNSDateComponents",
     runFunction: run_ObjectiveCBridgeFromNSDateComponents, tags: t,
     setUpFunction: setup_dateComponents),
+  BenchmarkInfo(name: "ObjectiveCBridgeASCIIStringFromFile",
+                runFunction: run_ASCIIStringFromFile, tags: ts,
+                setUpFunction: setup_ASCIIStringFromFile),
 ]
 
 #if _runtime(_ObjC)
@@ -709,3 +712,35 @@ public func run_ObjectiveCBridgeFromNSDateComponents(_ N: Int) {
   }
   #endif
 }
+
+var ASCIIStringFromFile:String? = nil
+public func setup_ASCIIStringFromFile() {
+  #if _runtime(_ObjC)
+  let url:URL
+  if #available(OSX 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *) {
+    url = FileManager.default.temporaryDirectory.appendingPathComponent(
+      "sphinx.txt"
+    )
+  } else {
+    url = URL(fileURLWithPath: "/tmp/sphinx.txt")
+  }
+  var str = "Sphinx of black quartz judge my vow"
+  str = Array(repeating: str, count: 100).joined()
+  try? str.write(
+    to: url,
+    atomically: true,
+    encoding: .ascii
+  )
+  ASCIIStringFromFile = try! String(contentsOf: url, encoding: .ascii)
+  #endif
+}
+
+@inline(never)
+public func run_ASCIIStringFromFile(_ N: Int) {
+  #if _runtime(_ObjC)
+  for _ in 0 ..< N {
+    blackHole((ASCIIStringFromFile! + "").utf8.count)
+  }
+  #endif
+}
+