---

yaml
---
r: 293820
b: refs/heads/tensorflow
c: 4e86c8f
h: refs/heads/master

Author: DougGregor

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: a1af0e45cb013cdc342d8c1ddfd00956c441a919
+refs/heads/tensorflow: 4e86c8ff52aebdd4b19950f5e2b4bbb6d2822b62
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/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.

branches/tensorflow/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/tensorflow/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/tensorflow/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/tensorflow/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
+}
+

branches/tensorflow/benchmark/utils/TestsUtils.swift

@@ -151,6 +151,21 @@ public struct BenchmarkInfo {
     return _tearDownFunction
   }
 
+  /// DON'T USE ON NEW BENCHMARKS!
+  /// Optional `legacyFactor` is a multiplication constant applied to runtime
+  /// statistics reported in the benchmark summary (it doesn’t affect the
+  /// individual sample times reported in `--verbose` mode).
+  ///
+  /// It enables the migration of benchmark suite to smaller workloads (< 1 ms),
+  /// which are more robust to measurement errors from system under load,
+  /// while maintaining the continuity of longterm benchmark tracking.
+  ///
+  /// Most legacy benchmarks had workloads artificially inflated in their main
+  /// `for` loops with a constant integer factor and the migration consisted of
+  /// dividing it so that the optimized runtime (-O) was less than 1000 μs and
+  /// storing the divisor in `legacyFactor`. This effectively only increases the
+  /// frequency of measurement, gathering more samples that are much less likely
+  /// to be interrupted by a context switch.
   public var legacyFactor: Int?
 
   public init(name: String, runFunction: @escaping (Int) -> (), tags: [BenchmarkCategory],
@@ -221,6 +236,29 @@ public func Random() -> Int64 {
   return lfsrRandomGenerator.randInt()
 }
 
+// This is a fixed-increment version of Java 8's SplittableRandom generator.
+// It is a very fast generator passing BigCrush, with 64 bits of state.
+// See http://dx.doi.org/10.1145/2714064.2660195 and
+// http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html
+//
+// Derived from public domain C implementation by Sebastiano Vigna
+// See http://xoshiro.di.unimi.it/splitmix64.c
+public struct SplitMix64: RandomNumberGenerator {
+    private var state: UInt64
+
+    public init(seed: UInt64) {
+        self.state = seed
+    }
+
+    public mutating func next() -> UInt64 {
+        self.state &+= 0x9e3779b97f4a7c15
+        var z: UInt64 = self.state
+        z = (z ^ (z &>> 30)) &* 0xbf58476d1ce4e5b9
+        z = (z ^ (z &>> 27)) &* 0x94d049bb133111eb
+        return z ^ (z &>> 31)
+    }
+}
+
 @inlinable // FIXME(inline-always)
 @inline(__always)
 public func CheckResults(