swift-mirror/benchmark/single-source/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

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

protocol Constructible {
  associatedtype Element
  init(e:Element)
}
class ConstructibleArray<T:Constructible> {
  var array : [T]

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

// Reference to a POD class.
class POD : Constructible {
  typealias Element=Int
  var x: Int
  required init(e:Int) { self.x = e }
}

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

class Dummy {}

// Reference to a reference. The nested reference is shared across elements.
class CommonRef : Constructible {
  typealias Element=Dummy
  var d: Dummy
  required init(e:Dummy) { self.d = e }
}

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

enum RefEnum {
  case None
  case Some(Dummy)
}

// Reuse the same enum value for each element.
class RefArray<T> {
  var array : [T]

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

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

// Struct holding a reference.
struct S : Constructible {
  typealias Element=Dummy
  var d: Dummy
  init(e:Dummy) { self.d = e }
}

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

@inline(never)
public func run_ArrayOfRef(_ n: Int) {
  for _ in 0..<n {
    genPODRefArray()
    genCommonRefArray()
    genRefEnumArray()
    genRefStructArray()
  }
}