1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//===--- CxxVectorSum.swift -----------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2012 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
//
//===----------------------------------------------------------------------===//
// This is a benchmark that tracks how quickly Swift can sum up a C++ vector
// as compared to the C++ implementation of such sum.
import TestsUtils
#if SWIFT_PACKAGE
// FIXME: Needs fix for https://github.com/apple/swift/issues/61547.
public let benchmarks = [BenchmarkInfo]()
#else
import CxxStdlibPerformance
import Cxx
public let benchmarks = [
BenchmarkInfo(
name: "CxxVecU32.sum.Cxx.rangedForLoop",
runFunction: run_CxxVectorOfU32_Sum_Cxx_RangedForLoop,
tags: [.validation, .bridging, .cxxInterop],
setUpFunction: makeVectorOnce),
BenchmarkInfo(
name: "CxxVecU32.sum.Swift.forInLoop",
runFunction: run_CxxVectorOfU32_Sum_Swift_ForInLoop,
tags: [.validation, .bridging, .cxxInterop],
setUpFunction: makeVectorOnce),
BenchmarkInfo(
name: "CxxVecU32.sum.Swift.iteratorLoop",
runFunction: run_CxxVectorOfU32_Sum_Swift_RawIteratorLoop,
tags: [.validation, .bridging, .cxxInterop],
setUpFunction: makeVectorOnce),
BenchmarkInfo(
name: "CxxVecU32.sum.Swift.subscriptLoop",
runFunction: run_CxxVectorOfU32_Sum_Swift_IndexAndSubscriptLoop,
tags: [.validation, .bridging, .cxxInterop],
setUpFunction: makeVectorOnce),
BenchmarkInfo(
name: "CxxVecU32.sum.Swift.reduce",
runFunction: run_CxxVectorOfU32_Sum_Swift_Reduce,
tags: [.validation, .bridging, .cxxInterop],
setUpFunction: makeVectorOnce)
]
func makeVectorOnce() {
initVector(vectorSize)
}
// FIXME: compare CxxVectorOfU32SumInCxx to CxxVectorOfU32SumInSwift and
// establish an expected threshold of performance, which when exceeded should
// fail the benchmark.
// FIXME: Bump up to 50k and 10 once the sequence is faster.
let vectorSize = 25_000
let iterRepeatFactor = 7
@inline(never)
public func run_CxxVectorOfU32_Sum_Cxx_RangedForLoop(_ n: Int) {
let sum = testVector32Sum(vectorSize, n * iterRepeatFactor)
blackHole(sum)
}
@inline(never)
public func run_CxxVectorOfU32_Sum_Swift_ForInLoop(_ n: Int) {
let vectorOfU32 = makeVector32(vectorSize)
var sum: UInt32 = 0
for _ in 0..<(n * iterRepeatFactor) {
for x in vectorOfU32 {
sum = sum &+ x
}
}
blackHole(sum)
}
// This function should have comparable performance to
// `run_CxxVectorOfU32_Sum_Cxx_RangedForLoop`.
@inline(never)
public func run_CxxVectorOfU32_Sum_Swift_RawIteratorLoop(_ n: Int) {
let vectorOfU32 = makeVector32(vectorSize)
var sum: UInt32 = 0
for _ in 0..<(n * iterRepeatFactor) {
var b = vectorOfU32.__beginUnsafe()
let e = vectorOfU32.__endUnsafe()
while b != e {
sum = sum &+ b.pointee
b = b.successor()
}
}
blackHole(sum)
}
// Need to wait for https://github.com/apple/swift/issues/61499
@inline(never)
public func run_CxxVectorOfU32_Sum_Swift_IndexAndSubscriptLoop(_ n: Int) {
#if FIXED_61499
let vectorOfU32 = makeVector32(vectorSize)
var sum: UInt32 = 0
for _ in 0..<(n * iterRepeatFactor) {
for i in 0..<vectorOfU32.size() {
sum = sum &+ vectorOfU32[i]
}
}
blackHole(sum)
#else
run_CxxVectorOfU32_Sum_Swift_RawIteratorLoop(n)
#endif
}
@inline(never)
public func run_CxxVectorOfU32_Sum_Swift_Reduce(_ n: Int) {
let vectorOfU32 = makeVector32(vectorSize)
var sum: UInt32 = 0
for _ in 0..<(n * iterRepeatFactor) {
sum = vectorOfU32.reduce(sum, &+)
}
blackHole(sum)
}
#endif
|
