MapReduce.swift

//===--- MapReduce.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
//
//===----------------------------------------------------------------------===//

import TestsUtils
import Foundation

lett:[BenchmarkCategory]=[.validation,.algorithm]
letts:[BenchmarkCategory]=[.validation,.algorithm,.String]

publicletbenchmarks=[
BenchmarkInfo(name:"MapReduce", runFunction: run_MapReduce, tags: t),
BenchmarkInfo(name:"MapReduceAnyCollection",
 runFunction: run_MapReduceAnyCollection, tags: t),
BenchmarkInfo(name:"MapReduceAnyCollectionShort",
 runFunction: run_MapReduceAnyCollectionShort, tags: t, legacyFactor:10),
BenchmarkInfo(name:"MapReduceClass2",
 runFunction: run_MapReduceClass, tags: t,
 setUpFunction:{boxedNumbers(1000)}, tearDownFunction: releaseDecimals),
BenchmarkInfo(name:"MapReduceClassShort2",
 runFunction: run_MapReduceClassShort, tags: t,
 setUpFunction:{boxedNumbers(10)}, tearDownFunction: releaseDecimals),
BenchmarkInfo(name:"MapReduceNSDecimalNumber",
 runFunction: run_MapReduceNSDecimalNumber, tags: t,
 setUpFunction:{decimals(1000)}, tearDownFunction: releaseDecimals),
BenchmarkInfo(name:"MapReduceNSDecimalNumberShort",
 runFunction: run_MapReduceNSDecimalNumberShort, tags: t,
 setUpFunction:{decimals(10)}, tearDownFunction: releaseDecimals),
BenchmarkInfo(name:"MapReduceLazyCollection",
 runFunction: run_MapReduceLazyCollection, tags: t),
BenchmarkInfo(name:"MapReduceLazyCollectionShort",
 runFunction: run_MapReduceLazyCollectionShort, tags: t),
BenchmarkInfo(name:"MapReduceLazySequence",
 runFunction: run_MapReduceLazySequence, tags: t),
BenchmarkInfo(name:"MapReduceSequence",
 runFunction: run_MapReduceSequence, tags: t),
BenchmarkInfo(name:"MapReduceShort",
 runFunction: run_MapReduceShort, tags: t, legacyFactor:10),
BenchmarkInfo(name:"MapReduceShortString",
 runFunction: run_MapReduceShortString, tags: ts),
BenchmarkInfo(name:"MapReduceString",
 runFunction: run_MapReduceString, tags: ts),
]

#if _runtime(_ObjC)
vardecimals:[NSDecimalNumber]!
func decimals(_ n:Int){
 decimals =(0..<n).map{NSDecimalNumber(value: $0)}
}
func releaseDecimals(){ decimals =nil}
#else
func decimals(_ n:Int){}
func releaseDecimals(){}
#endif

classBox{
varv:Int
init(_ v:Int){self.v = v }
}

varboxedNumbers:[Box]!
func boxedNumbers(_ n:Int){ boxedNumbers =(0..<n).map{Box($0)}}
func releaseboxedNumbers(){ boxedNumbers =nil}

@inline(never)
publicfunc run_MapReduce(_ n:Int){
varnumbers=[Int](0..<1000)

varc=0
for_in1...n*100 {
 numbers = numbers.map{ $0 &+5}
 c = c &+ numbers.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceAnyCollection(_ n:Int){
letnumbers=AnyCollection([Int](0..<1000))

varc=0
for_in1...n*100 {
letmapped= numbers.map{ $0 &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceAnyCollectionShort(_ n:Int){
letnumbers=AnyCollection([Int](0..<10))

varc=0
for_in1...n*1_000 {
letmapped= numbers.map{ $0 &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceShort(_ n:Int){
varnumbers=[Int](0..<10)

varc=0
for_in1...n*1_000 {
 numbers = numbers.map{ $0 &+5}
 c = c &+ numbers.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceSequence(_ n:Int){
letnumbers=sequence(first:0){ $0 <1000? $0 &+1:nil}

varc=0
for_in1...n*100 {
letmapped= numbers.map{ $0 &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceLazySequence(_ n:Int){
letnumbers=sequence(first:0){ $0 <1000? $0 &+1:nil}

varc=0
for_in1...n*100 {
letmapped= numbers.lazy.map{ $0 &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceLazyCollection(_ n:Int){
letnumbers=[Int](0..<1000)

varc=0
for_in1...n*100 {
letmapped= numbers.lazy.map{ $0 &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceLazyCollectionShort(_ n:Int){
letnumbers=[Int](0..<10)

varc=0
for_in1...n*10000 {
letmapped= numbers.lazy.map{ $0 &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceString(_ n:Int){
lets="thequickbrownfoxjumpsoverthelazydogusingasmanycharacteraspossible123456789"

varc:UInt64=0
for_in1...n*100 {
 c = c &+ s.utf8.map {UInt64($0 &+5)}.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceShortString(_ n:Int){
lets="12345"

varc:UInt64=0
for_in1...n*100 {
 c = c &+ s.utf8.map {UInt64($0 &+5)}.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceNSDecimalNumber(_ n:Int){
#if _runtime(_ObjC)
letnumbers:[NSDecimalNumber]= decimals

varc=0
for_in1...n*10 {
letmapped= numbers.map{ $0.intValue &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
#endif
}

@inline(never)
publicfunc run_MapReduceNSDecimalNumberShort(_ n:Int){
#if _runtime(_ObjC)
letnumbers:[NSDecimalNumber]= decimals

varc=0
for_in1...n*1_000 {
letmapped= numbers.map{ $0.intValue &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
#endif
}


@inline(never)
publicfunc run_MapReduceClass(_ n:Int){
letnumbers:[Box]= boxedNumbers

varc=0
for_in1...n*10 {
letmapped= numbers.map{ $0.v &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}

@inline(never)
publicfunc run_MapReduceClassShort(_ n:Int){
letnumbers:[Box]= boxedNumbers

varc=0
for_in1...n*1_000 {
letmapped= numbers.map{ $0.v &+5}
 c = c &+ mapped.reduce(0,&+)
}
check(c !=0)
}