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
|
//===--- ArrayOfGenericPOD.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
//
//===----------------------------------------------------------------------===//
// This benchmark tests creation and destruction of arrays of enum and
// generic type bound to trivial types. It should take the same time as
// ArrayOfPOD. (In practice, it takes a little longer to construct
// the optional arrays).
//
// For comparison, we always create three arrays of 200,000 words.
// An integer enum takes two words.
import TestsUtils
public let benchmarks = [
BenchmarkInfo(
// Renamed benchmark to "2" when IUO test was removed, which
// effectively changed what we're benchmarking here.
name: "ArrayOfGenericPOD2",
runFunction: run_ArrayOfGenericPOD,
tags: [.validation, .api, .Array]),
// Initialize an array of generic POD from a slice.
// This takes a unique path through stdlib customization points.
BenchmarkInfo(
name: "ArrayInitFromSlice",
runFunction: run_initFromSlice,
tags: [.validation, .api, .Array], setUpFunction: createArrayOfPOD)
]
class RefArray<T> {
var array: [T]
init(_ i:T) {
array = [T](repeating: i, count: 100000)
}
}
// Check the performance of destroying an array of enums (optional) where the
// enum has a single payload of trivial type. Destroying the
// elements should be a nop.
@inline(never)
func genEnumArray() {
blackHole(RefArray<Int?>(3))
// should be a nop
}
// Check the performance of destroying an array of structs where the
// struct has multiple fields of trivial type. Destroying the
// elements should be a nop.
struct S<T> {
var x: T
var y: T
}
@inline(never)
func genStructArray() {
blackHole(RefArray<S<Int>>(S(x:3, y:4)))
// should be a nop
}
@inline(never)
public func run_ArrayOfGenericPOD(_ n: Int) {
for _ in 0..<n {
genEnumArray()
genStructArray()
}
}
// --- ArrayInitFromSlice
let globalArray = Array<UInt8>(repeating: 0, count: 4096)
func createArrayOfPOD() {
blackHole(globalArray)
}
@inline(never)
@_optimize(none)
func copyElements<S: Sequence>(_ contents: S) -> [UInt8]
where S.Iterator.Element == UInt8
{
return [UInt8](contents)
}
@inline(never)
public func run_initFromSlice(_ n: Int) {
for _ in 0..<n {
for _ in 0..<1000 {
// Slice off at least one element so the array buffer can't be reused.
blackHole(copyElements(globalArray[0..<4095]))
}
}
}
|
