Merge tag 'swift-DEVELOPMENT-SNAPSHOT-2019-07-10-a' into tensorflow-merge

Tag build swift-DEVELOPMENT-SNAPSHOT-2019-07-10-a

Author: rxwei

Diff for: CMakeLists.txt

@@ -1100,6 +1100,8 @@ endif()
 if(SWIFT_BUILD_STDLIB)
   add_subdirectory(stdlib)
 else()
+  add_subdirectory(stdlib/public/legacy_layouts)
+
   # Some tools (e.g. swift-reflection-dump) rely on a host swiftReflection, so
   # ensure we build that when building tools.
   if(SWIFT_INCLUDE_TOOLS)

Diff for: benchmark/CMakeLists.txt

@@ -78,6 +78,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictionaryRemove
     single-source/DictionarySubscriptDefault
     single-source/DictionarySwap
+    single-source/Diffing
     single-source/DropFirst
     single-source/DropLast
     single-source/DropWhile
@@ -104,6 +105,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Memset
     single-source/MonteCarloE
     single-source/MonteCarloPi
+    single-source/Myers
     single-source/NSDictionaryCastToSwift
     single-source/NSError
     single-source/NSStringConversion

Diff for: benchmark/single-source/AngryPhonebook.swift

@@ -13,13 +13,60 @@
 // This test is based on single-source/Phonebook, with
 // to test uppercase and lowercase ASCII string fast paths.
 import TestsUtils
-import Foundation
 
-public let AngryPhonebook = BenchmarkInfo(
-  name: "AngryPhonebook",
-  runFunction: run_AngryPhonebook,
-  tags: [.validation, .api, .String],
-  legacyFactor: 7)
+let t: [BenchmarkCategory] = [.validation, .api, .String]
+
+public let AngryPhonebook = [
+  BenchmarkInfo(
+    name: "AngryPhonebook",
+    runFunction: run_AngryPhonebook,
+    tags: t,
+    legacyFactor: 7),
+
+  // Small String Workloads
+  BenchmarkInfo(
+    name: "AngryPhonebook.ASCII.Small",
+    runFunction: { angryPhonebook($0, ascii) },
+    tags: t,
+    setUpFunction: { blackHole(ascii) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Strasse.Small",
+    runFunction: { angryPhonebook($0, strasse) },
+    tags: t,
+    setUpFunction: { blackHole(strasse) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Armenian.Small",
+    runFunction: { angryPhonebook($0, armenian) },
+    tags: t,
+    setUpFunction: { blackHole(armenian) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Cyrillic.Small",
+    runFunction: { angryPhonebook($0, cyrillic) },
+    tags: t,
+    setUpFunction: { blackHole(cyrillic) }),
+
+  // Regular String Workloads
+  BenchmarkInfo(
+    name: "AngryPhonebook.ASCII",
+    runFunction: { angryPhonebook($0, precomposed: longASCII) },
+    tags: t,
+    setUpFunction: { blackHole(longASCII) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Strasse",
+    runFunction: { angryPhonebook($0, precomposed: longStrasse) },
+    tags: t,
+    setUpFunction: { blackHole(longStrasse) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Armenian",
+    runFunction: { angryPhonebook($0, precomposed: longArmenian) },
+    tags: t,
+    setUpFunction: { blackHole(longArmenian) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Cyrillic",
+    runFunction: { angryPhonebook($0, precomposed: longCyrillic) },
+    tags: t,
+    setUpFunction: { blackHole(longCyrillic) })
+]
 
 let words = [
   "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph",
@@ -39,3 +86,67 @@ public func run_AngryPhonebook(_ N: Int) {
     }
   }
 }
+
+// Workloads for various scripts. Always 20 names for 400 pairings.
+// To keep the performance of various scripts roughly comparable, aim for
+// a total length of approximately 120 characters.
+// E.g.: `ascii.joined(separator: "").count == 124`
+// Every name should fit in 15-bytes UTF-8 encoded, to excercise the small
+// string optimization.
+// E.g.: `armenian.allSatisfy { $0._guts.isSmall } == true`
+
+// Workload Size Statistics
+//   SMALL  | UTF-8 | UTF-16 |    REGULAR   |  UTF-8  | UTF-16
+// ---------|-------|--------|--------------|---------|--------
+//    ascii | 124 B |  248 B |    longASCII |  6158 B | 12316 B
+//  strasse | 140 B |  240 B |  longStrasse |  6798 B | 11996 B
+// armenian | 232 B |  232 B | longArmenian | 10478 B | 11676 B
+// cyrillic | 238 B |  238 B | longCyrillic | 10718 B | 11916 B
+
+let ascii = Array(words.prefix(20))
+// Pathological case, uppercase: ß -> SS
+let strasse = Array(repeating: "Straße", count: 20)
+
+let armenian = [
+  "Արմեն", "Աննա", "Հարութ", "Միքայել", "Մարիա", "Դավիթ", "Վարդան",
+  "Նարինե", "Տիգրան", "Տաթևիկ", "Թագուհի", "Թամարա", "Ազնաուր", "Գրիգոր",
+  "Կոմիտաս", "Հայկ", "Գառնիկ", "Վահրամ", "Վահագն", "Գևորգ"]
+
+let cyrillic = [
+  "Ульяна", "Аркадий", "Аня", "Даниил", "Дмитрий", "Эдуард", "Юрій", "Давид",
+  "Анна", "Дмитрий", "Евгений", "Борис", "Ксения", "Артур", "Аполлон",
+  "Соломон", "Николай", "Кристи", "Надежда", "Спартак"]
+
+/// Precompose the phonebook into one large string of comma separated names.
+func phonebook(_ names: [String]) -> String {
+  names.map { firstName in
+    names.map { lastName in
+      firstName + " " + lastName
+    }.joined(separator: ", ")
+  }.joined(separator: ", ")
+}
+
+let longASCII = phonebook(ascii)
+let longStrasse = phonebook(strasse)
+let longArmenian = phonebook(armenian)
+let longCyrillic = phonebook(cyrillic)
+
+@inline(never)
+public func angryPhonebook(_ N: Int, _ names: [String]) {
+  assert(names.count == 20)
+  // Permute the names.
+  for _ in 1...N {
+    for firstname in names {
+      for lastname in names {
+        blackHole((firstname.uppercased(), lastname.lowercased()))
+      }
+    }
+  }
+}
+
+@inline(never)
+public func angryPhonebook(_ N: Int, precomposed names: String) {
+  for _ in 1...N {
+    blackHole((names.uppercased(), names.lowercased()))
+  }
+}

Diff for: benchmark/single-source/BinaryFloatingPointConversionFromBinaryInteger.swift

@@ -13,7 +13,6 @@
 // This test checks performance of generic binary floating-point conversion from
 // a binary integer.
 
-import Foundation
 import TestsUtils
 
 #if swift(>=4.2)
@@ -110,7 +109,7 @@ extension MockBinaryInteger : BinaryInteger {
   var trailingZeroBitCount: Int {
     return _value.trailingZeroBitCount
   }
-  
+
   func isMultiple(of other: MockBinaryInteger<T>) -> Bool {
     return _value.isMultiple(of: other._value)
   }
@@ -211,4 +210,3 @@ public func run_BinaryFloatingPointConversionFromBinaryInteger(_ N: Int) {
 }
 
 #endif
-

Diff for: benchmark/single-source/BinaryFloatingPointProperties.swift

@@ -10,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import TestsUtils
 
 public let BinaryFloatingPointPropertiesBinade = BenchmarkInfo(

Diff for: benchmark/single-source/BitCount.swift

@@ -13,7 +13,6 @@
 // This test checks performance of Swift bit count.
 // and mask operator.
 // rdar://problem/22151678
-import Foundation
 import TestsUtils
 
 public let BitCount = BenchmarkInfo(

Diff for: benchmark/single-source/BucketSort.swift

@@ -16,17 +16,16 @@
 // 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
+// is not known to the call site at line 89, 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
+// `public` and the lines 88-90 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.
+// specialize line 89 for `InsertionSort` on integers.
 
 import TestsUtils
-import Foundation
 
 public let BucketSort = BenchmarkInfo(
   name: "BucketSort",
@@ -117,7 +116,8 @@ let items: [Int] = {
 let buckets: [Bucket<Int>] = {
   let bucketCount = 10
   let maxValue = items.max()!.convertToInt()
-  let maxCapacity = Int(ceil(Double(maxValue + 1) / Double(bucketCount)))
+  let maxCapacity = Int(
+    (Double(maxValue + 1) / Double(bucketCount)).rounded(.up))
   return (0..<bucketCount).map { _ in Bucket<Int>(capacity: maxCapacity) }
 }()
 

Diff for: benchmark/single-source/ByteSwap.swift

@@ -13,7 +13,6 @@
 // This test checks performance of Swift byte swap.
 // rdar://problem/22151907
 
-import Foundation
 import TestsUtils
 
 public let ByteSwap = BenchmarkInfo(

Diff for: benchmark/single-source/CString.swift

@@ -13,6 +13,8 @@
 import TestsUtils
 #if os(Linux)
 import Glibc
+#elseif os(Windows)
+import MSVCRT
 #else
 import Darwin
 #endif

Diff for: benchmark/single-source/Calculator.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 import TestsUtils
-import Foundation
 
 public let Calculator = BenchmarkInfo(
   name: "Calculator",
@@ -53,4 +52,3 @@ public func run_Calculator(_ N: Int) {
   }
   CheckResults(c == 0)
 }
-

Diff for: benchmark/single-source/Diffing.swift

@@ -0,0 +1,125 @@
+//===--- Diffing.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
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+let t: [BenchmarkCategory] = [.api]
+public let Diffing = [
+  BenchmarkInfo(
+    name: "DiffSame",
+    runFunction: run_DiffSame,
+    tags: t,
+    legacyFactor: 10),
+  BenchmarkInfo(
+    name: "DiffPangramToAlphabet",
+    runFunction: run_DiffPangramToAlphabet,
+    tags: t,
+    legacyFactor: 10),
+  BenchmarkInfo(
+    name: "DiffPangrams",
+    runFunction: run_DiffPangrams,
+    tags: t,
+    legacyFactor: 10),
+  BenchmarkInfo(
+    name: "DiffReversedAlphabets",
+    runFunction: run_DiffReversedAlphabets,
+    tags: t,
+    legacyFactor: 10),
+  BenchmarkInfo(
+    name: "DiffReversedLorem",
+    runFunction: run_DiffReversedLorem,
+    tags: t,
+    legacyFactor: 10),
+  BenchmarkInfo(
+    name: "DiffDisparate",
+    runFunction: run_DiffDisparate,
+    tags: t,
+    legacyFactor: 10),
+  BenchmarkInfo(
+    name: "DiffSimilar",
+    runFunction: run_DiffSimilar,
+    tags: t,
+    legacyFactor: 10),
+]
+
+let numbersAndSymbols = Array("0123456789`~!@#$%^&*()+=_-\"'?/<,>.\\{}'")
+let alphabets = Array("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+let alphabetsReversed = Array("ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba")
+let longPangram = Array("This pangram contains four As, one B, two Cs, one D, thirty Es, six Fs, five Gs, seven Hs, eleven Is, one J, one K, two Ls, two Ms, eighteen Ns, fifteen Os, two Ps, one Q, five Rs, twenty-seven Ss, eighteen Ts, two Us, seven Vs, eight Ws, two Xs, three Ys, & one Z")
+let typingPangram = Array("The quick brown fox jumps over the lazy dog")
+let loremIpsum = Array("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
+let unabridgedLorem = Array("Lorem ipsum, quia dolor sit amet consectetur adipisci[ng] velit, sed quia non-numquam [do] eius modi tempora inci[di]dunt, ut labore et dolore magnam aliqua.")
+let loremReverse = Array(".auqila angam erolod te erobal tu tnudidicni ropmet domsuie od des ,tile gnicsipida rutetcesnoc ,tema tis rolod muspi meroL")
+
+
+@inline(never)
+public func run_DiffSame(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = longPangram.difference(from: longPangram)
+    }
+  }
+}
+
+@inline(never)
+public func run_DiffPangramToAlphabet(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = longPangram.difference(from: alphabets)
+    }
+  }
+}
+
+@inline(never)
+public func run_DiffPangrams(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = longPangram.difference(from: typingPangram)
+    }
+  }
+}
+
+@inline(never)
+public func run_DiffReversedAlphabets(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = alphabets.difference(from: alphabetsReversed)
+    }
+  }
+}
+
+@inline(never)
+public func run_DiffReversedLorem(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = loremIpsum.difference(from: loremReverse)
+    }
+  }
+}
+
+@inline(never)
+public func run_DiffDisparate(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = alphabets.difference(from: numbersAndSymbols)
+    }
+  }
+}
+
+@inline(never)
+public func run_DiffSimilar(_ N: Int) {
+  if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
+    for _ in 1...N {
+      let _ = loremIpsum.difference(from: unabridgedLorem)
+    }
+  }
+}

Diff for: benchmark/single-source/Hanoi.swift

@@ -12,7 +12,6 @@
 
 // This test checks performance of Swift hanoi tower.
 // <rdar://problem/22151932>
-import Foundation
 import TestsUtils
 
 public let Hanoi = BenchmarkInfo(