benchmark/single-source/StaticArray.swift

//===--- StaticArray.swift ------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// We use this test to benchmark the compile time and analyze the code
// generation of struct initializers.
//===----------------------------------------------------------------------===//

import TestsUtils

protocol StaticArrayProtocol {
  associatedtype ElemTy
  init(_ defaultValue : ElemTy)
  func get(_ idx : Int) -> ElemTy
  mutating func set(_ idx : Int,_ val : ElemTy)
  func count() -> Int
}

struct A0<ElemTy> : StaticArrayProtocol {
  init(_ defaultValue : ElemTy) { x = defaultValue }
  var x : ElemTy
  func get(_ idx : Int) -> ElemTy { if idx == 0 { return x } else { fatalError("oob"); } }
  mutating func set(_ idx : Int,_ val : ElemTy) { if idx == 0 { x = val }}
  func count() -> Int { return 1}
}

struct A2X<T : StaticArrayProtocol> : StaticArrayProtocol {
  init(_ defaultValue : T.ElemTy) { lower = T(defaultValue); upper = T(defaultValue) }
  var lower : T
  var upper : T
  func get(_ idx: Int) -> T.ElemTy { let size = lower.count(); if idx < size { return lower.get(idx) } else { return upper.get(idx - size) }}
  mutating func set(_ idx: Int,_ val : T.ElemTy) {let size = lower.count(); if idx < size { return lower.set(idx, val) } else { return upper.set(idx - size, val) }}
  func count() -> Int { return upper.count() + lower.count() }
}

struct StaticArray<
  T : StaticArrayProtocol
> : StaticArrayProtocol, RandomAccessCollection, MutableCollection {
  typealias Indices = CountableRange<Int>
  
  init(_ defaultValue : T.ElemTy) { values = T(defaultValue) }
  var values : T
  func get(_ idx: Int) -> T.ElemTy { return values.get(idx) }
  mutating func set(_ idx: Int,_ val : T.ElemTy) { return values.set(idx, val) }
  func count() -> Int { return values.count() }

  typealias Index = Int
  typealias IndexDistance = Int
  let startIndex: Int = 0
  var endIndex: Int { return count()}

  subscript(idx: Int) -> T.ElemTy {
    get {
      return get(idx)
    }
    set(val) {
      set(idx, val)
    }
  }

  typealias Iterator = IndexingIterator<StaticArray>

  subscript(bounds: Range<Index>) -> StaticArray<T> {
    get { fatalError() }
    set { fatalError() }
  }
}

typealias SA2Int   = StaticArray<A0<Int>>
typealias SA4Int   = StaticArray<A2X<A0<Int>>>
typealias SA8Int   = StaticArray<A2X<A2X<A0<Int>>>>
typealias SA16Int  = StaticArray<A2X<A2X<A2X<A0<Int>>>>>
typealias SA32Int  = StaticArray<A2X<A2X<A2X<A2X<A0<Int>>>>>>
typealias SA64Int  = StaticArray<A2X<A2X<A2X<A2X<A2X<A0<Int>>>>>>>
typealias SA128Int = StaticArray<A2X<A2X<A2X<A2X<A2X<A2X<A0<Int>>>>>>>>

// Make sure the optimizer does not optimize the compute away.
@inline(never)
public func sink(_ value: Int) { if False() { print(value) }}


@inline(never)
public func run_StaticArray(_ N: Int) {

  for _ in 1...N {
    var staticArray = SA128Int(0)
    for i in 0..<staticArray.count() { staticArray[i] = i ^ 123 }
    staticArray.sort()
    sink(staticArray[0])
  }
}