Merge branch 'master' into fix/SR-7799

Author: Suyash Srijan

apinotes/CMakeLists.txt

@@ -28,6 +28,10 @@ add_custom_target("copy_apinotes"
     COMMENT "Copying API notes to ${output_dir}"
     SOURCES "${sources}")
 
+# 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
-    FILES ${sources}
-    DESTINATION "lib/swift/apinotes")
+    DIRECTORY "${output_dir}"
+    DESTINATION "lib/swift/"
+    OPTIONAL)

benchmark/CMakeLists.txt

@@ -58,7 +58,6 @@ set(SWIFT_BENCH_MODULES
     single-source/ClassArrayGetter
     single-source/Codable
     single-source/Combos
-    single-source/CountAlgo
     single-source/DataBenchmarks
     single-source/DeadArray
     single-source/DictOfArraysToArrayOfDicts
@@ -90,7 +89,6 @@ set(SWIFT_BENCH_MODULES
     single-source/FloatingPointPrinting
     single-source/Hanoi
     single-source/Hash
-    single-source/HashQuadratic
     single-source/Histogram
     single-source/InsertCharacter  
     single-source/Integrate

benchmark/Naming.md

@@ -28,8 +28,8 @@ benchmark is testing individual method on a concrete type.
 ````
 ⛔️ Dictionary2
 ✅ AngryPhonebook
-✅ Dictionary.AnyHashable.String.update
 ✅ Array.append.Array.Int
+✅ Dictionary.AnyHashable.String.update
 ````
 
 Benchmark names are used to run individual tests when passed as command line
@@ -42,8 +42,8 @@ optional chaining etc.
 
 ````
 ✅ Array.append.Array.Int?
-✅ Flatten.Array.Tuple4.for-in.reserved
 ✅ Bridging.NSArray.as!.Array.NSString
+✅ Flatten.Array.Tuple4.for-in.Reserve
 ````
 
 Note: Special characters that could be interpreted by the shell require escaping

benchmark/scripts/Benchmark_Driver

@@ -200,7 +200,7 @@ class BenchmarkDriver(object):
         with open(log_file, 'w') as f:
             f.write(output)
 
-    RESULT = '{:>3} {:<25} {:>7} {:>7} {:>6} {:>10} {:>6} {:>7} {:>10}'
+    RESULT = '{:>3} {:<40} {:>7} {:>7} {:>6} {:>10} {:>6} {:>7} {:>10}'
 
     def run_and_log(self, csv_console=True):
         """Run benchmarks and continuously log results to the console.

benchmark/scripts/compare_perf_tests.py

@@ -363,9 +363,9 @@ def _reset(self):
     # Parse lines like this
     # #,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs)
     results_re = re.compile(
-        r'( *\d+[, \t]+[\w.]+[, \t]+' +  # #,TEST
-        r'[, \t]+'.join([r'\d+'] * 2) +  # at least 2...
-        r'(?:[, \t]+\d*)*)')             # ...or more numeric columns
+        r'( *\d+[, \t]+[\w.\-\?!]+[, \t]+' +  # #,TEST
+        r'[, \t]+'.join([r'\d+'] * 2) +       # at least 2...
+        r'(?:[, \t]+\d*)*)')                  # ...or more numeric columns
 
     def _append_result(self, result):
         columns = result.split(',') if ',' in result else result.split()

benchmark/scripts/run_smoke_bench

@@ -185,7 +185,7 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
     tests = TestComparator(results[0], results[1], threshold)
     changed = tests.decreased + tests.increased
 
-    while len(changed) > 0 and unchanged_length_count < 5:
+    while len(changed) > 0 and unchanged_length_count < 10:
         i += 1
         if VERBOSE:
             log('        test again: ' + str([test.name for test in changed]))
@@ -205,25 +205,6 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
                           threshold * 1.4, output_file, *results)
 
 
-def get_results(bench_dir, opt_level, num_samples, to_test):
-    try:
-        exe = os.path.join(bench_dir, 'bin', 'Benchmark_' + opt_level)
-        args = [exe, '--num-samples=' + str(num_samples),
-                '--sample-time=0.0025']
-        if to_test:
-            args += to_test
-        env = {'DYLD_LIBRARY_PATH': os.path.join(bench_dir, 'lib', 'swift',
-               'macos'),
-               'SWIFT_DETERMINISTIC_HASHING': '1'}
-        output = subprocess.check_output(args, env=env)
-    except subprocess.CalledProcessError as e:
-        sys.stderr.write(e.output)
-        sys.stderr.flush()
-        return sys.exit(e.returncode)
-    else:
-        return output
-
-
 def report_code_size(opt_level, old_dir, new_dir, platform, output_file):
     if opt_level == 'swiftlibs':
         files = glob.glob(os.path.join(old_dir, 'lib', 'swift', platform,

benchmark/scripts/test_Benchmark_Driver.py

@@ -366,10 +366,10 @@ def mock_run(test):
         self.assertEqual(log, header + csv_log)
         self.assertEqual(
             out.getvalue(),
-            '  # TEST                      SAMPLES MIN(μs) Q1(μs)' +
-            ' MEDIAN(μs) Q3(μs) MAX(μs) MAX_RSS(B)\n' +
-            '  3 b1                              5     101    102' +
-            '        103    104     105        888\n' +
+            '  # TEST                                     SAMPLES MIN(μs)' +
+            ' Q1(μs) MEDIAN(μs) Q3(μs) MAX(μs) MAX_RSS(B)\n' +
+            '  3 b1                                             5     101' +
+            '    102        103    104     105        888\n' +
             '\n' +
             'Total performance tests executed: 1\n')
 

benchmark/scripts/test_compare_perf_tests.py

@@ -445,14 +445,20 @@ class TestLogParser(unittest.TestCase):
     def test_parse_results_csv(self):
         """Ignores uknown lines, extracts data from supported formats."""
         log = """#,TEST,SAMPLES,MIN(us),MAX(us),MEAN(us),SD(us),MEDIAN(us)
-34,BitCount,20,3,4,4,0,4
+7,Array.append.Array.Int?,20,10,10,10,0,10
+21,Bridging.NSArray.as!.Array.NSString,20,11,11,11,0,11
+42,Flatten.Array.Tuple4.lazy.for-in.Reserve,20,3,4,4,0,4
 
 Total performance tests executed: 1
 """
         parser = LogParser()
         results = parser.parse_results(log.splitlines())
         self.assertTrue(isinstance(results[0], PerformanceTestResult))
-        self.assertEqual(results[0].name, 'BitCount')
+        self.assertEquals(results[0].name, 'Array.append.Array.Int?')
+        self.assertEquals(results[1].name,
+                          'Bridging.NSArray.as!.Array.NSString')
+        self.assertEquals(results[2].name,
+                          'Flatten.Array.Tuple4.lazy.for-in.Reserve')
 
     def test_parse_results_tab_delimited(self):
         log = '34\tBitCount\t20\t3\t4\t4\t0\t4'

benchmark/single-source/ArrayInClass.swift

@@ -11,12 +11,19 @@
 //===----------------------------------------------------------------------===//
 
 import TestsUtils
-public let ArrayInClass = BenchmarkInfo(
-  name: "ArrayInClass",
-  runFunction: run_ArrayInClass,
-  tags: [.validation, .api, .Array],
-  setUpFunction: { ac = ArrayContainer() },
-  tearDownFunction: { ac = nil })
+public let ArrayInClass = [
+  BenchmarkInfo(
+    name: "ArrayInClass",
+    runFunction: run_ArrayInClass,
+    tags: [.validation, .api, .Array],
+    setUpFunction: { ac = ArrayContainer() },
+    tearDownFunction: { ac = nil }),
+  BenchmarkInfo(name: "DistinctClassFieldAccesses",
+    runFunction: run_DistinctClassFieldAccesses,
+    tags: [.unstable, .api, .Array],
+    setUpFunction: { workload = ClassWithArrs(N: 100_000) },
+    tearDownFunction: { workload = nil }),
+]
 
 var ac: ArrayContainer!
 
@@ -41,3 +48,38 @@ public func run_ArrayInClass(_ N: Int) {
   let a = ac!
   a.runLoop(N)
 }
+
+class ClassWithArrs {
+  var N: Int = 0
+  var A: [Int]
+  var B: [Int]
+
+  init(N: Int) {
+    self.N = N
+
+    A = [Int](repeating: 0, count: N)
+    B = [Int](repeating: 0, count: N)
+  }
+
+  func readArr() {
+    for i in 0..<self.N {
+      guard A[i] == B[i] else { fatalError("") }
+    }
+  }
+
+  func writeArr() {
+    for i in 0..<self.N {
+      A[i] = i
+      B[i] = i
+    }
+  }
+}
+
+var workload: ClassWithArrs!
+
+public func run_DistinctClassFieldAccesses(_ N: Int) {
+  for _ in 1...N {
+    workload.writeArr()
+    workload.readArr()
+  }
+}

benchmark/single-source/ArrayLiteral.swift

@@ -16,7 +16,7 @@
 import TestsUtils
 
 public let ArrayLiteral = [
-  BenchmarkInfo(name: "ArrayLiteral", runFunction: run_ArrayLiteral, tags: [.validation, .api, .Array]),
+  BenchmarkInfo(name: "ArrayLiteral2", runFunction: run_ArrayLiteral, tags: [.validation, .api, .Array]),
   BenchmarkInfo(name: "ArrayValueProp", runFunction: run_ArrayValueProp, tags: [.validation, .api, .Array]),
   BenchmarkInfo(name: "ArrayValueProp2", runFunction: run_ArrayValueProp2, tags: [.validation, .api, .Array]),
   BenchmarkInfo(name: "ArrayValueProp3", runFunction: run_ArrayValueProp3, tags: [.validation, .api, .Array]),
@@ -31,7 +31,7 @@ func makeArray() -> [Int] {
 @inline(never)
 public func run_ArrayLiteral(_ N: Int) {
   for _ in 1...10000*N {
-    _ = makeArray()
+    blackHole(makeArray())
   }
 }
 

benchmark/single-source/ArrayOfGenericPOD.swift

@@ -20,12 +20,21 @@
 
 import TestsUtils
 
-public let ArrayOfGenericPOD = BenchmarkInfo(
-  // Renamed benchmark to "2" when IUO test was removed, which
-  // effectively changed what we're benchmarking here.
-  name: "ArrayOfGenericPOD2",
-  runFunction: run_ArrayOfGenericPOD,
-  tags: [.validation, .api, .Array])
+public let ArrayOfGenericPOD = [
+  BenchmarkInfo(
+    // Renamed benchmark to "2" when IUO test was removed, which
+    // effectively changed what we're benchmarking here.
+    name: "ArrayOfGenericPOD2",
+    runFunction: run_ArrayOfGenericPOD,
+    tags: [.validation, .api, .Array]),
+
+  // Initialize an array of generic POD from a slice.
+  // This takes a unique path through stdlib customization points.
+  BenchmarkInfo(
+    name: "ArrayInitFromSlice",
+    runFunction: run_initFromSlice,
+    tags: [.validation, .api, .Array], setUpFunction: createArrayOfPOD)
+]
 
 class RefArray<T> {
   var array: [T]
@@ -64,3 +73,29 @@ public func run_ArrayOfGenericPOD(_ N: Int) {
     genStructArray()
   }
 }
+
+// --- ArrayInitFromSlice
+
+var globalArray = Array<UInt8>(repeating: 0, count: 4096)
+
+func createArrayOfPOD() {
+  blackHole(globalArray)
+}
+
+@inline(never)
+@_optimize(none)
+func copyElements<S: Sequence>(_ contents: S) -> [UInt8]
+  where S.Iterator.Element == UInt8
+{
+  return [UInt8](contents)
+}
+
+@inline(never)
+public func run_initFromSlice(_ N: Int) {
+  for _ in 0..<N {
+    for _ in 0..<1000 {
+      // Slice off at least one element so the array buffer can't be reused.
+      blackHole(copyElements(globalArray[0..<4095]))
+    }
+  }
+}

benchmark/single-source/ArraySetElement.swift

@@ -18,8 +18,7 @@ import TestsUtils
 public var ArraySetElement = BenchmarkInfo(
   name: "ArraySetElement",
   runFunction: run_ArraySetElement,
-  tags: [.runtime, .cpubench, .unstable],
-  legacyFactor: 10
+  tags: [.runtime, .cpubench]
 )
 
 // This is an effort to defeat isUniquelyReferenced optimization. Ideally
@@ -31,7 +30,7 @@ func storeArrayElement(_ array: inout [Int], _ i: Int) {
 
 public func run_ArraySetElement(_ N: Int) {
   var array = [Int](repeating: 0, count: 10000)
-  for _ in 0..<N {
+  for _ in 0..<10*N {
     for i in 0..<array.count {
       storeArrayElement(&array, i)
     }

benchmark/single-source/Codable.swift

@@ -107,18 +107,6 @@ public func setup_json() {
   JSONTester = CodablePerfTester(encoder: JSONEncoder(), decoder: JSONDecoder())
 }
 
-#if !_runtime(_ObjC)
-// If we do not have an objc-runtime, then we do not have a definition for
-// autoreleasepool. Add in our own fake autoclosure for it that is inline
-// always. That should be able to be eaten through by the optimizer no problem.
-@inline(__always)
-public func autoreleasepool<Result>(
-  invoking body: () throws -> Result
-) rethrows -> Result {
-  return try body()
-}
-#endif
-
 @inline(never)
 public func run_JSONPerfEncode(_ N: Int) {
   autoreleasepool {