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
|
//===--- ReversedCollections.swift ----------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2021 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
//
//===----------------------------------------------------------------------===//
import TestsUtils
public let benchmarks = [
BenchmarkInfo(name: "ReversedArray2", runFunction: run_ReversedArray, tags: [.validation, .api, .Array],
setUpFunction: { blackHole(arrayInput) },
tearDownFunction: { arrayInput = nil }),
BenchmarkInfo(name: "ReversedBidirectional", runFunction: run_ReversedBidirectional, tags: [.validation, .api, .cpubench]),
BenchmarkInfo(name: "ReversedDictionary2", runFunction: run_ReversedDictionary, tags: [.validation, .api, .Dictionary],
setUpFunction: { blackHole(dictionaryInput) },
tearDownFunction: { dictionaryInput = nil })
]
// These benchmarks compare the performance of iteration through several
// collection types after being reversed.
let length = 100_000
var arrayInput: [Int]! = Array(repeating: 1, count: length).reversed()
@inline(never)
public func run_ReversedArray(_ n: Int) {
let reversedArray: [Int] = arrayInput
// Iterate over the underlying type
// ReversedRandomAccessCollection<Array<Int>>
for _ in 1...n {
for item in reversedArray {
blackHole(item)
}
}
}
@inline(never)
public func run_ReversedBidirectional(_ n: Int) {
// Iterate over the underlying type
// ReversedCollection<AnyBidirectionalCollection<Int>>
for _ in 1...n {
let bidirectional = AnyBidirectionalCollection(0..<length)
let reversedBidirectional = bidirectional.reversed()
for item in reversedBidirectional {
blackHole(item)
}
}
}
var dictionaryInput: [(Int, Int)]! = {
var dictionary = [Int: Int]()
for k in 0..<length {
dictionary[k] = k
}
return dictionary.reversed()
}()
@inline(never)
public func run_ReversedDictionary(_ n: Int) {
let reversedDictionary: [(Int, Int)] = dictionaryInput
// Iterate over the underlying type
// Array<(Int, Int)>
for _ in 1...n {
for (key, value) in reversedDictionary {
blackHole(key)
blackHole(value)
}
}
}
|
