Merge pull request swiftlang#16953 from gottesmm/pr-06f7b1dfb03e403b21cbd8127a3a4cc7aeabfbf2

[benchmark] Add two low level Radix2CooleyTukey benchmarks.

Author: gottesmm

benchmark/CMakeLists.txt

@@ -125,6 +125,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Queue
     single-source/RC4
     single-source/RGBHistogram
+    single-source/Radix2CooleyTukey
     single-source/RandomShuffle
     single-source/RandomValues
     single-source/RangeAssignment

benchmark/single-source/Radix2CooleyTukey.swift

@@ -0,0 +1,258 @@
+// Radix2CooleyTukey benchmark
+//
+// Originally written by @owensd. Used with his permission.
+
+import Foundation
+import TestsUtils
+
+public var Radix2CooleyTukey = [
+  BenchmarkInfo(
+    name: "Radix2CooleyTukey",
+    runFunction: run_Radix2CooleyTukey,
+    tags: [.validation, .algorithm],
+    setUpFunction: setUpRadix2CooleyTukey,
+    tearDownFunction: tearDownRadix2CooleyTukey),
+  BenchmarkInfo(
+    name: "Radix2CooleyTukeyf",
+    runFunction: run_Radix2CooleyTukeyf,
+    tags: [.validation, .algorithm],
+    setUpFunction: setUpRadix2CooleyTukeyf,
+    tearDownFunction: tearDownRadix2CooleyTukeyf),
+]
+
+//===----------------------------------------------------------------------===//
+// Double Benchmark
+//===----------------------------------------------------------------------===//
+
+var double_input_real: UnsafeMutablePointer<Double>?
+var double_input_imag: UnsafeMutablePointer<Double>?
+var double_output_real: UnsafeMutablePointer<Double>?
+var double_output_imag: UnsafeMutablePointer<Double>?
+var double_temp_real: UnsafeMutablePointer<Double>?
+var double_temp_imag: UnsafeMutablePointer<Double>?
+
+let doubleN = 65_536
+let doubleSize = { MemoryLayout<Double>.size * doubleN }()
+
+func setUpRadix2CooleyTukey() {
+  let size = doubleSize
+
+  double_input_real = UnsafeMutablePointer<Double>.allocate(capacity: size)
+  double_input_imag = UnsafeMutablePointer<Double>.allocate(capacity: size)
+  double_output_real = UnsafeMutablePointer<Double>.allocate(capacity: size)
+  double_output_imag = UnsafeMutablePointer<Double>.allocate(capacity: size)
+  double_temp_real = UnsafeMutablePointer<Double>.allocate(capacity: size)
+  double_temp_imag = UnsafeMutablePointer<Double>.allocate(capacity: size)
+}
+
+func tearDownRadix2CooleyTukey() {
+  double_input_real?.deallocate()
+  double_input_imag?.deallocate()
+  double_output_real?.deallocate()
+  double_output_imag?.deallocate()
+  double_temp_real?.deallocate()
+  double_temp_imag?.deallocate()
+}
+
+func Radix2CooleyTukey(_ level: Int,
+  input_real: UnsafeMutablePointer<Double>,
+  input_imag: UnsafeMutablePointer<Double>,
+  stride: Int, output_real: UnsafeMutablePointer<Double>,
+  output_imag: UnsafeMutablePointer<Double>,
+  temp_real: UnsafeMutablePointer<Double>,
+  temp_imag: UnsafeMutablePointer<Double>) {
+  if level == 0 {
+    output_real[0] = input_real[0];
+    output_imag[0] = input_imag[0];
+    return
+  }
+  let length = 1 << level
+  let half = length >> 1
+  Radix2CooleyTukey(level - 1,
+    input_real: input_real,
+    input_imag: input_imag,
+    stride: stride << 1,
+    output_real: temp_real,
+    output_imag: temp_imag,
+    temp_real: output_real,
+    temp_imag: output_imag)
+  Radix2CooleyTukey(level - 1,
+    input_real: input_real + stride,
+    input_imag: input_imag + stride,
+    stride: stride << 1,
+    output_real: temp_real + half,
+    output_imag: temp_imag + half,
+    temp_real: output_real + half,
+    temp_imag: output_imag + half)
+  for idx in 0..<half {
+    let angle = -Double.pi * Double(idx) / Double(half)
+    let _cos = cos(angle)
+    let _sin = sin(angle)
+    output_real[idx] = temp_real[idx] + _cos *
+    temp_real[idx + half] - _sin * temp_imag[idx + half]
+    output_imag[idx] = temp_imag[idx] + _cos *
+    temp_imag[idx + half] + _sin *
+    temp_real[idx + half]
+    output_real[idx + half] = temp_real[idx] - _cos *
+    temp_real[idx + half] + _sin *
+    temp_imag[idx + half]
+    output_imag[idx + half] = temp_imag[idx] - _cos *
+    temp_imag[idx + half] - _sin *
+    temp_real[idx + half]
+  }
+}
+
+func testDouble(iter: Int) {
+  let stride = 1
+
+  let size = doubleSize
+  let level = Int(log2(Double(doubleN)))
+
+  let input_real = double_input_real._unsafelyUnwrappedUnchecked
+  let input_imag = double_input_imag._unsafelyUnwrappedUnchecked
+  let output_real = double_output_real._unsafelyUnwrappedUnchecked
+  let output_imag = double_output_imag._unsafelyUnwrappedUnchecked
+  let temp_real = double_temp_real._unsafelyUnwrappedUnchecked
+  let temp_imag = double_temp_imag._unsafelyUnwrappedUnchecked
+
+  for _ in 0..<iter {
+    memset(UnsafeMutableRawPointer(input_real), 0, size)
+    memset(UnsafeMutableRawPointer(input_imag), 0, size)
+    memset(UnsafeMutableRawPointer(output_real), 0, size)
+    memset(UnsafeMutableRawPointer(output_imag), 0, size)
+    memset(UnsafeMutableRawPointer(temp_real), 0, size)
+    memset(UnsafeMutableRawPointer(temp_imag), 0, size)
+
+    Radix2CooleyTukey(level,
+      input_real: input_real,
+      input_imag: input_imag,
+      stride: stride,
+      output_real: output_real,
+      output_imag: output_imag,
+      temp_real: temp_real,
+      temp_imag: temp_imag)
+  }
+}
+
+@inline(never)
+public func run_Radix2CooleyTukey(_ N: Int) {
+  testDouble(iter: N)
+}
+
+//===----------------------------------------------------------------------===//
+// Float Benchmark
+//===----------------------------------------------------------------------===//
+
+let floatN = 65_536
+let floatSize = { MemoryLayout<Float>.size * floatN }()
+
+var float_input_real: UnsafeMutablePointer<Float>?
+var float_input_imag: UnsafeMutablePointer<Float>?
+var float_output_real: UnsafeMutablePointer<Float>?
+var float_output_imag: UnsafeMutablePointer<Float>?
+var float_temp_real: UnsafeMutablePointer<Float>?
+var float_temp_imag: UnsafeMutablePointer<Float>?
+
+func setUpRadix2CooleyTukeyf() {
+  let size = floatSize
+  float_input_real = UnsafeMutablePointer<Float>.allocate(capacity: size)
+  float_input_imag = UnsafeMutablePointer<Float>.allocate(capacity: size)
+  float_output_real = UnsafeMutablePointer<Float>.allocate(capacity: size)
+  float_output_imag = UnsafeMutablePointer<Float>.allocate(capacity: size)
+  float_temp_real = UnsafeMutablePointer<Float>.allocate(capacity: size)
+  float_temp_imag = UnsafeMutablePointer<Float>.allocate(capacity: size)
+}
+
+func tearDownRadix2CooleyTukeyf() {
+  float_input_real?.deallocate()
+  float_input_imag?.deallocate()
+  float_output_real?.deallocate()
+  float_output_imag?.deallocate()
+  float_temp_real?.deallocate()
+  float_temp_imag?.deallocate()
+}
+
+func Radix2CooleyTukeyf(_ level: Int,
+  input_real: UnsafeMutablePointer<Float>,
+  input_imag: UnsafeMutablePointer<Float>,
+  stride: Int, output_real: UnsafeMutablePointer<Float>,
+  output_imag: UnsafeMutablePointer<Float>,
+  temp_real: UnsafeMutablePointer<Float>,
+  temp_imag: UnsafeMutablePointer<Float>) {
+  if level == 0 {
+    output_real[0] = input_real[0];
+    output_imag[0] = input_imag[0];
+    return
+  }
+  let length = 1 << level
+  let half = length >> 1
+  Radix2CooleyTukeyf(level - 1,
+    input_real: input_real,
+    input_imag: input_imag,
+    stride: stride << 1,
+    output_real: temp_real,
+    output_imag: temp_imag,
+    temp_real: output_real,
+    temp_imag: output_imag)
+  Radix2CooleyTukeyf(level - 1,
+    input_real: input_real + stride,
+    input_imag: input_imag + stride,
+    stride: stride << 1,
+    output_real: temp_real + half,
+    output_imag: temp_imag + half,
+    temp_real: output_real + half,
+    temp_imag: output_imag + half)
+  for idx in 0..<half {
+    let angle = -Float.pi * Float(idx) / Float(half)
+    let _cos = cosf(angle)
+    let _sin = sinf(angle)
+    output_real[idx] = temp_real[idx] + _cos *
+    temp_real[idx + half] - _sin * temp_imag[idx + half]
+    output_imag[idx] = temp_imag[idx] + _cos *
+    temp_imag[idx + half] + _sin * temp_real[idx + half]
+    output_real[idx + half] = temp_real[idx] - _cos *
+    temp_real[idx + half] + _sin *
+    temp_imag[idx + half]
+    output_imag[idx + half] = temp_imag[idx] - _cos *
+    temp_imag[idx + half] - _sin *
+    temp_real[idx + half]
+  }
+}
+
+func testFloat(iter: Int) {
+  let stride = 1
+  let n = floatN
+  let size = floatSize
+
+  let input_real = float_input_real._unsafelyUnwrappedUnchecked
+  let input_imag = float_input_imag._unsafelyUnwrappedUnchecked
+  let output_real = float_output_real._unsafelyUnwrappedUnchecked
+  let output_imag = float_output_imag._unsafelyUnwrappedUnchecked
+  let temp_real = float_temp_real._unsafelyUnwrappedUnchecked
+  let temp_imag = float_temp_imag._unsafelyUnwrappedUnchecked
+
+  let level = Int(log2(Float(n)))
+
+  for _ in 0..<iter {
+    memset(UnsafeMutableRawPointer(input_real), 0, size)
+    memset(UnsafeMutableRawPointer(input_imag), 0, size)
+    memset(UnsafeMutableRawPointer(output_real), 0, size)
+    memset(UnsafeMutableRawPointer(output_imag), 0, size)
+    memset(UnsafeMutableRawPointer(temp_real), 0, size)
+    memset(UnsafeMutableRawPointer(temp_imag), 0, size)
+
+    Radix2CooleyTukeyf(level,
+      input_real: input_real,
+      input_imag: input_imag,
+      stride: stride,
+      output_real: output_real,
+      output_imag: output_imag,
+      temp_real: temp_real,
+      temp_imag: temp_imag)
+  }
+}
+
+@inline(never)
+public func run_Radix2CooleyTukeyf(_ N: Int) {
+  testFloat(iter: N)
+}

benchmark/utils/main.swift

@@ -114,6 +114,7 @@ import ProtocolDispatch2
 import Queue
 import RC4
 import RGBHistogram
+import Radix2CooleyTukey
 import RandomShuffle
 import RandomValues
 import RangeAssignment
@@ -274,6 +275,7 @@ registerBenchmark(QueueGeneric)
 registerBenchmark(QueueConcrete)
 registerBenchmark(RC4Test)
 registerBenchmark(RGBHistogram)
+registerBenchmark(Radix2CooleyTukey)
 registerBenchmark(RandomShuffle)
 registerBenchmark(RandomValues)
 registerBenchmark(RangeAssignment)