---

yaml
---
r: 347641
b: refs/heads/master
c: 33d9e52
h: refs/heads/master
i:
  347639: 53fbb18

Author: bob-wilson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 90f691eef4aee378af27084030679214a1a39d50
+refs/heads/master: 33d9e52e7222f815352aab0634e21e30d9c624a5
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/CMakeLists.txt

@@ -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.

trunk/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)

trunk/benchmark/CMakeLists.txt

@@ -43,6 +43,7 @@ set(SWIFT_BENCH_MODULES
     single-source/BinaryFloatingPointProperties
     single-source/BitCount
     single-source/Breadcrumbs
+    single-source/BucketSort
     single-source/ByteSwap
     single-source/COWTree
     single-source/COWArrayGuaranteedParameterOverhead
@@ -85,6 +86,7 @@ set(SWIFT_BENCH_MODULES
     single-source/ExistentialPerformance
     single-source/Fibonacci
     single-source/FlattenList
+    single-source/FloatingPointParsing
     single-source/FloatingPointPrinting
     single-source/Hanoi
     single-source/Hash

trunk/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))
   }
 

trunk/benchmark/single-source/BucketSort.swift

@@ -0,0 +1,131 @@
+//===--- BucketSort.swift -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+// 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
+//
+// 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
+
+public let BucketSort = BenchmarkInfo(
+  name: "BucketSort",
+  runFunction: run_BucketSort,
+  tags: [.validation, .algorithm],
+  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
+        for i in 0 ..< sortedItems.count {
+            var j = i
+            while j > 0 && sortedItems[j-1] > sortedItems[j] {
+                let temp = sortedItems[j-1]
+                sortedItems[j-1] = sortedItems[j]
+                sortedItems[j] = temp
+                j -= 1
+            }
+        }
+        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
+  init(capacity: Int) {
+    self.capacity = capacity
+    items = [T]()
+  }
+  mutating func add(_ item: T) {
+    if items.count < capacity {
+      items.append(item)
+    }
+  }
+  func sort(_ sortingAlgo: SortingAlgorithm) -> [T] {
+    return sortingAlgo.sort(items)
+  }
+}
+
+func bucketSort<T>(
+  _ items: [T], sortingAlgorithm: SortingAlgorithm, bucketArray: [Bucket<T>]
+) -> [T] {
+  var copyBucketArray = bucketArray
+  for item in items {
+    distribute(item, bucketArray: &copyBucketArray)
+  }
+  var sortedArray = [T]()
+  for bucket in copyBucketArray {
+    sortedArray += bucket.sort(sortingAlgorithm)
+  }
+  return sortedArray
+}
+
+func isAscending(_ a: [Int]) -> Bool {
+  return zip(a, a.dropFirst()).allSatisfy(<=)
+}
+
+let items: [Int] = {
+  var g = SplitMix64(seed: 42)
+  return (0..<10_000).map {_ in Int.random(in: 0..<1000, using: &g) }
+}()
+
+let buckets: [Bucket<Int>] = {
+  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 = bucketSort(
+      items, sortingAlgorithm: InsertionSort(), bucketArray: buckets)
+    CheckResults(isAscending(sortedArray))
+  }
+}