ArrayOfRef.swift

//===--- ArrayOfRef.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 an array of
// references. It is meant to be a baseline for comparison against
// ArrayOfGenericRef.
//
// For comparison, we always create four arrays of 1,000 words.

import TestsUtils

publicletbenchmarks=
BenchmarkInfo(
 name:"ArrayOfRef",
 runFunction: run_ArrayOfRef,
 tags:[.validation,.api,.Array],
 legacyFactor:10)

protocolConstructible{
associatedtypeElement
init(e:Element)
}
classConstructibleArray<T:Constructible>{
vararray:[T]

init(_ e:T.Element){
 array =[T]()
 array.reserveCapacity(1_000)
for_in0...1_000{
 array.append(T(e:e))
}
}
}

// Reference to a POD class.
classPOD:Constructible{
typealiasElement=Int
varx:Int
requiredinit(e:Int){self.x = e }
}

@inline(never)
func genPODRefArray(){
blackHole(ConstructibleArray<POD>(3))
 // should be a nop
}

classDummy{}

// Reference to a reference. The nested reference is shared across elements.
classCommonRef:Constructible{
typealiasElement=Dummy
vard:Dummy
requiredinit(e:Dummy){self.d = e }
}

@inline(never)
func genCommonRefArray(){
letd=Dummy()
blackHole(ConstructibleArray<CommonRef>(d))
 // should be a nop
}

enumRefEnum{
case None
case Some(Dummy)
}

// Reuse the same enum value for each element.
classRefArray<T>{
vararray:[T]

init(_ i:T, count:Int=1_000){
 array =[T](repeating: i, count: count)
}
}

@inline(never)
func genRefEnumArray(){
lete=RefEnum.Some(Dummy())
blackHole(RefArray<RefEnum>(e))
 // should be a nop
}

// Struct holding a reference.
structS:Constructible{
typealiasElement=Dummy
vard:Dummy
init(e:Dummy){self.d = e }
}

@inline(never)
func genRefStructArray(){
letd=Dummy()
blackHole(ConstructibleArray<S>(d))
 // should be a nop
}

@inline(never)
publicfunc run_ArrayOfRef(_ n:Int){
for_in0..<n {
genPODRefArray()
genCommonRefArray()
genRefEnumArray()
genRefStructArray()
}
}