swift-mirror/benchmark/single-source/CharacterProperties.swift.gyb

//===--- CharacterProperties.swift ----------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 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
//
//===----------------------------------------------------------------------===//

% # Ignore the following warning. This _is_ the correct file to edit.
////////////////////////////////////////////////////////////////////////////////
// WARNING: This file is manually generated from .gyb template and should not
// be directly modified. Instead, make changes to CharacterProperties.swift.gyb
// and run scripts/generate_harness/generate_harness.py to regenerate this file.
////////////////////////////////////////////////////////////////////////////////

import TestsUtils
import Foundation

public let CharacterPropertiesFetch = BenchmarkInfo(
  name: "CharacterPropertiesFetch",
  runFunction: run_CharacterPropertiesFetch,
  tags: [.validation, .api, .String],
  setUpFunction: { blackHole(workload) },
  legacyFactor: 10)

public let CharacterPropertiesStashed = BenchmarkInfo(
  name: "CharacterPropertiesStashed",
  runFunction: run_CharacterPropertiesStashed,
  tags: [.validation, .api, .String],
  setUpFunction: { setupStash() },
  legacyFactor: 10)

public let CharacterPropertiesStashedMemo = BenchmarkInfo(
  name: "CharacterPropertiesStashedMemo",
  runFunction: run_CharacterPropertiesStashedMemo,
  tags: [.validation, .api, .String],
  setUpFunction: { setupMemo() },
  legacyFactor: 10)

public let CharacterPropertiesPrecomputed = BenchmarkInfo(
  name: "CharacterPropertiesPrecomputed",
  runFunction: run_CharacterPropertiesPrecomputed,
  tags: [.validation, .api, .String],
  setUpFunction: { setupPrecomputed() },
  legacyFactor: 10)

extension Character {
  var firstScalar: UnicodeScalar { return unicodeScalars.first! }
}

% Properties = { "Alphanumeric": "alphanumerics", \
%              "Capitalized": "capitalizedLetters", \
%              "Control": "controlCharacters", \
%              "Decimal": "decimalDigits", \
%              "Letter": "letters", \
%              "Lowercase": "lowercaseLetters", \
%              "Uppercase": "uppercaseLetters", \
%              "Newline": "newlines", \
%              "Whitespace": "whitespaces", \
%              "Punctuation": "punctuationCharacters" \
%              }

// Fetch the CharacterSet for every call
% for Property, Set in Properties.items():
func is${Property}(_ c: Character) -> Bool {
  return CharacterSet.${Set}.contains(c.firstScalar)
}
% end

// Stash the set
% for Property, Set in Properties.items():
let ${Set} = CharacterSet.${Set}
func is${Property}Stashed(_ c: Character) -> Bool {
  return ${Set}.contains(c.firstScalar)
}
% end

func setupStash() {
  blackHole(workload)
% for Property, Set in Properties.items():
    blackHole(${Set})
% end
}

// Memoize the stashed set
% for Property, Set in Properties.items():
var ${Set}Memo = Set<UInt32>()
func is${Property}StashedMemo(_ c: Character) -> Bool {
  let scalar = c.firstScalar
  if ${Set}Memo.contains(scalar.value) { return true }
  if ${Set}.contains(scalar) {
    ${Set}Memo.insert(scalar.value)
    return true
  }
  return false
}
% end

func setupMemo() {
  blackHole(workload)
% for Property, Set in Properties.items():
    blackHole(${Set}Memo)
% end
}

// Precompute whole scalar set
func precompute(_ charSet: CharacterSet, capacity: Int) -> Set<UInt32> {
  var result = Set<UInt32>(minimumCapacity: capacity)
  for plane in 0...0x10 {
    guard charSet.hasMember(inPlane: UInt8(plane)) else { continue }
    let offset = plane &* 0x1_0000
    for codePoint in 0...0xFFFF {
      guard let scalar = UnicodeScalar(codePoint &+ offset) else { continue }
      if charSet.contains(scalar) {
        result.insert(scalar.value)
      }
    }
  }
  return result
}
%{  #// Reduce wide memory range. Capacities from `print("${Set}:…` below.
  precomputed_capacity = dict(
    controlCharacters=24951, alphanumerics=122647, lowercaseLetters=2063,
    punctuationCharacters=770, whitespaces=19, letters=121145,
    uppercaseLetters=1733, decimalDigits=590, newlines=7,
    capitalizedLetters=31
  )
}%
% for Property, Set in Properties.items():
var ${Set}Precomputed: Set<UInt32> =
  precompute(${Set}, capacity: ${precomputed_capacity[Set]})
func is${Property}Precomputed(_ c: Character) -> Bool {
  return ${Set}Precomputed.contains(c.firstScalar.value)
}
% end

func setupPrecomputed() {
  blackHole(workload)
% for Property, Set in Properties.items():
    blackHole(${Set}Precomputed)
%#//    print("${Set}: \(${Set}Precomputed.count)")
% end
}

// Compute on the fly
//
// TODO: If UnicodeScalars ever exposes category, etc., implement the others!
func isNewlineComputed(_ c: Character) -> Bool {
  switch c.firstScalar.value {
    case 0x000A...0x000D: return true
    case 0x0085: return true
    case 0x2028...0x2029: return true
    default: return false
  }
}

let workload = """
  the quick brown 🦊 jumped over the lazy 🐶.
  в чащах юга жил-был цитрус? да, но фальшивый экземпляр
  𓀀𓀤𓁓𓁲𓃔𓃗𓃀𓃁𓃂𓃃𓆌𓆍𓆎𓆏𓆐𓆑𓆒𓆲𓁿
  🝁ꃕ躍‾∾📦⺨
  👍👩‍👩‍👧‍👧👨‍👨‍👦‍👦🇺🇸🇨🇦🇲🇽👍🏻👍🏼👍🏽👍🏾👍🏿
  Lorem ipsum something something something...
"""

@inline(never)
public func run_CharacterPropertiesFetch(_ N: Int) {
  for _ in 1...N {
    for c in workload {
    % for Property, Set in Properties.items():
        blackHole(is${Property}(c))
    % end
    }
  }
}

@inline(never)
public func run_CharacterPropertiesStashed(_ N: Int) {
  for _ in 1...N {
    for c in workload {
    % for Property, Set in Properties.items():
        blackHole(is${Property}Stashed(c))
    % end
    }
  }
}

@inline(never)
public func run_CharacterPropertiesStashedMemo(_ N: Int) {
  for _ in 1...N {
    for c in workload {
    % for Property, Set in Properties.items():
        blackHole(is${Property}StashedMemo(c))
    % end
    }
  }
}

@inline(never)
public func run_CharacterPropertiesPrecomputed(_ N: Int) {
  for _ in 1...N {
    for c in workload {
    % for Property, Set in Properties.items():
        blackHole(is${Property}Precomputed(c))
    % end
    }
  }
}



// TODO: run_CharacterPropertiesComputed

// ${'Local Variables'}:
// eval: (read-only-mode 1)
// End: