//
// As discussed here:
// https://forums.swift.org/t/how-to-analyze-the-performance-of-for-example-this-little-program/10695
//
// This program demonstrates a regression in recent dev snapshots resulting
// in 4 times longer computation time for the last two of the four "range
// conversions" as seen below (on my MBP late 2013, macOS 10.13.3 (17D102)).
// 
//
// --------------------------------------------------------------------------
// Before Regression (using eg default toolchain of Xcode 9.2 and 9.3 beta 3)
// --------------------------------------------------------------------------
// › sudo xcode-select -s /Applications/Xcode-beta.app/
// › xcrun swiftc --version
// Apple Swift version 4.1 (swiftlang-902.0.41 clang-902.0.31)
// Target: x86_64-apple-darwin17.4.0
// 
// › xcrun swiftc -O -whole-module-optimization -gnone -static-stdlib test.swift
// › ./test
// 
// Range converting 100000000 values from UInt8 to UInt64:
//   trial 0: 0.132198705046903 seconds (checksum: 2170205185142300190)
//   trial 1: 0.109685704985168 seconds (checksum: 3761688987579986996)
//   trial 2: 0.110061422979925 seconds (checksum: 5642533481369980494)
//   trial 3: 0.114856946980581 seconds (checksum: 7740398493674204011)
//   trial 4: 0.111156655009836 seconds (checksum: 12659530246663417775)
// 
// Range converting 100000000 values from Int8 to UInt64:
//   trial 0: 0.109313847031444 seconds (checksum: 9476562641788044214)
//   trial 1: 0.11203276499873 seconds (checksum: 14323354221939181237)
//   trial 2: 0.117191826982889 seconds (checksum: 9548902814626120895)
//   trial 3: 0.109507674991619 seconds (checksum: 723401728380766742)
//   trial 4: 0.109779970021918 seconds (checksum: 2748926567846913555)
// 
// Range converting 100000000 values from UInt8 to Int64:
//   trial 0: 0.108220668975264 seconds (checksum: 5136152271503443783)
//   trial 1: 0.110781208029948 seconds (checksum: 3689348814741910323)
//   trial 2: 0.11080539698014 seconds (checksum: 4123389851770370361)
//   trial 3: 0.110172690998297 seconds (checksum: -4846791580151137092)
//   trial 4: 0.110611339041498 seconds (checksum: -6148914691236517206)
// 
// Range converting 100000000 values from Int8 to Int64:
//   trial 0: 0.110338026017416 seconds (checksum: 3544668469065757012)
//   trial 1: 0.122289317019749 seconds (checksum: -651061555542690115)
//   trial 2: 0.118017453001812 seconds (checksum: 1663823975275763472)
//   trial 3: 0.116950674972031 seconds (checksum: -3978709506094216977)
//   trial 4: 0.119433180021588 seconds (checksum: 6655295901103053869)
//
// NOTE: All four range conversions take about 0.1 seconds.
//
//
// --------------------------------------------------------------------------
// After Regression (I have tested dev snapshots 2018-02-25 ... 2018-03-08)
// --------------------------------------------------------------------------
// › /Library/Developer/Toolchains/swift-DEVELOPMENT-SNAPSHOT-2018-03-08-a.xctoolchain/usr/bin/swiftc \
// --version
// Apple Swift version 4.2-dev (LLVM c4ec2ab808, Clang af436f313e, Swift 74ba135008)
// Target: x86_64-apple-darwin17.4.0
//
// › /Library/Developer/Toolchains/swift-DEVELOPMENT-SNAPSHOT-2018-03-08-a.xctoolchain/usr/bin/swiftc \
// -sdk /Applications/Xcode-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk \
// -O -whole-module-optimization -gnone -static-stdlib test.swift
// › ./test
// 
// Range converting 100000000 values from UInt8 to UInt64:
//   trial 0: 0.144382501021028 seconds (checksum: 8897841259083430779)
//   trial 1: 0.120100836968049 seconds (checksum: 7306357456645743973)
//   trial 2: 0.113219286024105 seconds (checksum: 8825501086245354106)
//   trial 3: 0.115648402017541 seconds (checksum: 5642533481369980494)
//   trial 4: 0.113908740982879 seconds (checksum: 6655295901103053916)
// 
// Range converting 100000000 values from Int8 to UInt64:
//   trial 0: 0.156202154990751 seconds (checksum: 6510615555426900600)
//   trial 1: 0.120782539015636 seconds (checksum: 7378697629483820613)
//   trial 2: 0.12854404799873 seconds (checksum: 9042521604759584122)
//   trial 3: 0.119271910982206 seconds (checksum: 15336116641672254691)
//   trial 4: 0.121582918975037 seconds (checksum: 13238251629368031171)
// 
// Range converting 100000000 values from UInt8 to Int64:
//   trial 0: 0.397824143001344 seconds (checksum: 6655295901103053916)
//   trial 1: 0.402513558976352 seconds (checksum: -723401728380766731)
//   trial 2: 0.400139409000985 seconds (checksum: -8897841259083430780)
//   trial 3: 0.402008056000341 seconds (checksum: 5136152271503443783)
//   trial 4: 0.403440554044209 seconds (checksum: -8463800222054970742)
// 
// Range converting 100000000 values from Int8 to Int64:
//   trial 0: 0.415403343038633 seconds (checksum: -1374463283923456881)
//   trial 1: 0.420072704029735 seconds (checksum: 8680820740569200707)
//   trial 2: 0.40942423598608 seconds (checksum: 2170205185142300169)
//   trial 3: 0.420196880993899 seconds (checksum: 1880844493789993556)
//   trial 4: 0.422151803970337 seconds (checksum: 4340410370284600346)
//
// NOTE: The first two are still about 0.1 s, but the last two are 0.4 s.
//       That is, for some reason the last two are almost 4 times slower.
//
// --------------------------------------------------------------------------


import AppKit


extension FixedWidthInteger {
    
    /// Creates a new instance by mapping `source` from the full range of
    /// `Src` to the full range of `Self`.
    /// So for example:
    ///
    ///     Int8(rangeConverted: UInt8(  0)) == Int8(-128)
    ///     Int8(rangeConverted: UInt8(128)) == Int8(   0)
    ///     Int8(rangeConverted: UInt8(255)) == Int8( 127)
    ///
    ///     UInt32(rangeConverted: UInt8(0x00)) == UInt32(0x00_00_00_00)
    ///     UInt32(rangeConverted: UInt8(0x80)) == UInt32(0x80_80_80_80)
    ///     UInt32(rangeConverted: UInt8(0xff)) == UInt32(0xff_ff_ff_ff)
    ///
    ///     UInt16(rangeConverted: Int64.min) == UInt16.min
    ///     UInt16(rangeConverted: Int64(0) ) == UInt16(
    ///                                              (Double(UInt16.max) / 2)
    ///                                              .rounded())
    ///     UInt16(rangeConverted: Int64.max) == UInt16.max
    ///
    /// - Parameter source: An integer to map from the full range of its type
    ///                     to the full range of this type.
    init<Src>(rangeConverted source: Src) where Src: FixedWidthInteger {
        let srcBW = Src.bitWidth
        let dstBW = Self.bitWidth
        let source = Src.isSigned
            ? source &+ (Src(1) << (srcBW &- 1))
            : source
        if srcBW < dstBW {
            self = Self(truncatingIfNeeded: source)
            var shifts = srcBW
            while shifts < dstBW {
                self |= self << shifts
                shifts = shifts << 1
            }
        } else if srcBW > dstBW {
            let shifts = srcBW &- dstBW
            self = Self(truncatingIfNeeded: source >> shifts)
        } else {
            self = Self(truncatingIfNeeded: source)
        }
        if Self.isSigned {
            self = self &+ (Self(1) << (dstBW &- 1))
        }
    }
}

// This type is only a simple example context for this particular benchmark.
final class Buffer<Element: FixedWidthInteger> {
    var data: UnsafeMutableBufferPointer<Element>
    init(count: Int) {
        precondition(count > 0)
        data = UnsafeMutableBufferPointer<Element>.allocate(capacity: count)
        data.initialize(repeating: 0)
    }
    func setAllElementsToRandomBitPatterns() {
        let rc = SecRandomCopyBytes(nil, data.count, data.baseAddress!)
        precondition(rc == errSecSuccess)
    }
    func setElements<E>(from other: Buffer<E>, transform: (E) -> Element) {
        precondition(other.data.count <= data.count)
        for i in data.indices {
            data[i] = transform(other.data[i])
        }
    }
    func checksum() -> Element {
        var checksum = Element(0)
        for e in data { checksum = checksum ^ e }
        return checksum
    }
    deinit {
        data.deallocate()
    }
}

func benchmark<S, D>(source _: S.Type, destination _: D.Type)
    where S: FixedWidthInteger, D: FixedWidthInteger
{
    let num = 100_000_000
    print("\nRange converting \(num) values from \(S.self) to \(D.self):")
    let srcBuf = Buffer<S>(count: num)
    let dstBuf = Buffer<D>(count: num)
    for trial in 0 ..< 5 {
        srcBuf.setAllElementsToRandomBitPatterns()
        let t0 = CACurrentMediaTime()
        dstBuf.setElements(from: srcBuf, transform: D.init(rangeConverted:))
        let t1 = CACurrentMediaTime()
        print("  trial \(trial):",
            t1 - t0, "seconds (checksum: \(dstBuf.checksum()))")
    }
}

// This function is just here for completeness, in case anyone should find
// it interesting to see the benchmarks for all (8 * 8 = 64) conversions.
func benchmarkAll() {
    func benchAllSources<D: FixedWidthInteger>(withDestination: D.Type) {
        benchmark(source: UInt8.self, destination: D.self)
        benchmark(source: UInt16.self, destination: D.self)
        benchmark(source: UInt32.self, destination: D.self)
        benchmark(source: UInt64.self, destination: D.self)
        benchmark(source: Int8.self, destination: D.self)
        benchmark(source: Int16.self, destination: D.self)
        benchmark(source: Int32.self, destination: D.self)
        benchmark(source: Int64.self, destination: D.self)
    }
    benchAllSources(withDestination: UInt8.self)
    benchAllSources(withDestination: UInt16.self)
    benchAllSources(withDestination: UInt32.self)
    benchAllSources(withDestination: UInt64.self)
    benchAllSources(withDestination: Int8.self)
    benchAllSources(withDestination: Int16.self)
    benchAllSources(withDestination: Int32.self)
    benchAllSources(withDestination: Int64.self)
}

// But for the purpose of this demonstration, it suffices to look at
// this subset of conversions:
func benchmark8To64() {
    benchmark(source: UInt8.self, destination: UInt64.self)
    benchmark(source: Int8.self, destination: UInt64.self)
    benchmark(source: UInt8.self, destination: Int64.self)
    benchmark(source: Int8.self, destination: Int64.self)
}

benchmark8To64()