Merge branch 'master' into safe-conversion

Author: airspeedswift

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

benchmark/scripts/run_smoke_bench

@@ -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/single-source/CountAlgo.swift

@@ -20,8 +20,8 @@ public let DataBenchmarks = [
     runFunction: { for _ in 0..<$0*10_000 { blackHole(Data()) } },
     tags: d, legacyFactor: 10),
   BenchmarkInfo(name: "DataCreateSmall",
-    runFunction: { for _ in 0..<$0*100 { blackHole(sampleData(.small)) } },
-    tags: d, legacyFactor: 1000),
+    runFunction: { for _ in 0..<$0*10_000 { blackHole(sampleData(.small)) } },
+    tags: d, legacyFactor: 10),
   BenchmarkInfo(name: "DataCreateMedium",
     runFunction: { for _ in 0..<$0*100 { blackHole(sampleData(.medium)) } },
     tags: d, legacyFactor: 100),

benchmark/single-source/DataBenchmarks.swift

@@ -15,10 +15,10 @@ import TestsUtils
 public let Fibonacci = BenchmarkInfo(
   name: "Fibonacci",
   runFunction: run_Fibonacci,
-  tags: [.unstable, .algorithm])
+  tags: [.algorithm])
 
 func fibonacci(_ n: Int) -> Int {
-  if (n < 2) { return 1 }
+  if (n <= 2) { return 1 }
   return fibonacci(n - 2) + fibonacci(n - 1)
 }
 
@@ -28,14 +28,14 @@ func Fibonacci(_ n: Int) -> Int {
   // at compile time.
   if False() { return 0 }
 
-  if (n < 2) { return 1 }
+  if (n <= 2) { return 1 }
   return fibonacci(n - 2) + fibonacci(n - 1)
 }
 
 @inline(never)
 public func run_Fibonacci(_ N: Int) {
-  let n = 32
-  let ref_result = 3524578
+  let n = 24
+  let ref_result = 46368
   var result = 0
   for _ in 1...N {
     result = Fibonacci(n)

benchmark/single-source/Fibonacci.swift

@@ -19,47 +19,56 @@ public let FloatingPointPrinting = [
   BenchmarkInfo(
     name: "FloatingPointPrinting_Float_description_small",
     runFunction: run_FloatingPointPrinting_Float_description_small,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 108),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Double_description_small",
     runFunction: run_FloatingPointPrinting_Double_description_small,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 100),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Float80_description_small",
     runFunction: run_FloatingPointPrinting_Float80_description_small,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 108),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Float_description_uniform",
     runFunction: run_FloatingPointPrinting_Float_description_uniform,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 100),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Double_description_uniform",
     runFunction: run_FloatingPointPrinting_Double_description_uniform,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 100),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Float80_description_uniform",
     runFunction: run_FloatingPointPrinting_Float80_description_uniform,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 100),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Float_interpolated",
     runFunction: run_FloatingPointPrinting_Float_interpolated,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 200),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Double_interpolated",
     runFunction: run_FloatingPointPrinting_Double_interpolated,
-    tags: [.validation, .api, .runtime, .String]),
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 200),
 
   BenchmarkInfo(
     name: "FloatingPointPrinting_Float80_interpolated",
     runFunction: run_FloatingPointPrinting_Float80_interpolated,
-    tags: [.validation, .api, .runtime, .String])
+    tags: [.validation, .api, .runtime, .String],
+    legacyFactor: 200)
 ]
 
 // Generate descriptions for 100,000 values around 1.0.
@@ -75,7 +84,7 @@ public let FloatingPointPrinting = [
 
 @inline(never)
 public func run_FloatingPointPrinting_Float_description_small(_ N: Int) {
-  let count = 100_000
+  let count = 1_000
   for _ in 0..<N {
     for i in 1...count {
       let f = Float(i) / 101.0
@@ -86,7 +95,7 @@ public func run_FloatingPointPrinting_Float_description_small(_ N: Int) {
 
 @inline(never)
 public func run_FloatingPointPrinting_Double_description_small(_ N: Int) {
-  let count = 100_000
+  let count = 1_000
   for _ in 0..<N {
     for i in 1...count {
       let f = Double(i) / 101.0
@@ -101,7 +110,7 @@ public func run_FloatingPointPrinting_Float80_description_small(_ N: Int) {
 // On Darwin, long double is Float80 on x86, and Double otherwise.
 // On Linux, Float80 is at aleast available on x86.
 #if arch(x86_64) || arch(i386)
-  let count = 100_000
+  let count = 1_000
   for _ in 0..<N {
     for i in 1...count {
       let f = Float80(i) / 101.0
@@ -117,7 +126,7 @@ public func run_FloatingPointPrinting_Float80_description_small(_ N: Int) {
 
 @inline(never)
 public func run_FloatingPointPrinting_Float_description_uniform(_ N: Int) {
-  let count = 100_000
+  let count = 1_000
   let step = UInt32.max / UInt32(count)
   for _ in 0..<N {
     for i in 0..<count {
@@ -130,7 +139,7 @@ public func run_FloatingPointPrinting_Float_description_uniform(_ N: Int) {
 
 @inline(never)
 public func run_FloatingPointPrinting_Double_description_uniform(_ N: Int) {
-  let count = 100_000
+  let count = 1_000
   let step = UInt64.max / UInt64(count)
   for _ in 0..<N {
     for i in 0..<count {
@@ -147,7 +156,7 @@ public func run_FloatingPointPrinting_Float80_description_uniform(_ N: Int) {
 // On Darwin, long double is Float80 on x86, and Double otherwise.
 // On Linux, Float80 is at aleast available on x86.
 #if arch(x86_64) || arch(i386)
-  let count = 100_000
+  let count = 1_000
   let step = UInt64.max / UInt64(count)
   for _ in 0..<N {
     for i in 0..<count {
@@ -167,7 +176,7 @@ public func run_FloatingPointPrinting_Float80_description_uniform(_ N: Int) {
 
 @inline(never)
 public func run_FloatingPointPrinting_Float_interpolated(_ N: Int) {
-  let count = 100_000
+  let count = 500
   let step = UInt32.max / UInt32(count)
   for _ in 0..<N {
     for i in 0..<count {
@@ -180,7 +189,7 @@ public func run_FloatingPointPrinting_Float_interpolated(_ N: Int) {
 
 @inline(never)
 public func run_FloatingPointPrinting_Double_interpolated(_ N: Int) {
-  let count = 100_000
+  let count = 500
   let step = UInt64.max / UInt64(count)
   for _ in 0..<N {
     for i in 0..<count {
@@ -197,7 +206,7 @@ public func run_FloatingPointPrinting_Float80_interpolated(_ N: Int) {
 // On Darwin, long double is Float80 on x86, and Double otherwise.
 // On Linux, Float80 is at aleast available on x86.
 #if arch(x86_64) || arch(i386)
-  let count = 100_000
+  let count = 500
   let step = UInt64.max / UInt64(count)
   for _ in 0..<N {
     for i in 0..<count {
@@ -210,4 +219,3 @@ public func run_FloatingPointPrinting_Float80_interpolated(_ N: Int) {
 #endif // x86
 #endif // Darwin/Linux
 }
-