From cb4c656bc2643e2b7c75b01d64c0ea742d58088f Mon Sep 17 00:00:00 2001 From: Dave Abrahams Date: Tue, 27 Jun 2017 17:25:41 -0700 Subject: [PATCH] [stdlib] Add benchmarks for Character's unicodeScalars view In local testing, these benchmark results change as follows due to f212fac7171:
Regression (20) TEST | OLD | NEW | DELTA | SPEEDUP --- | --- | --- | --- | --- CharIteration_utf16_unicodeScalars | 33074 | 79510 | +140.4% | **0.42x** CharIteration_utf16_unicodeScalars_Backwards | 73826 | 115515 | +56.5% | **0.64x**
Improvement (43) TEST | OLD | NEW | DELTA | SPEEDUP --- | --- | --- | --- | --- CharIndexing_korean_unicodeScalars | 118425 | 10360 | -91.3% | **11.43x** CharIndexing_tweet_unicodeScalars_Backwards | 226366 | 19850 | -91.2% | **11.40x** CharIndexing_tweet_unicodeScalars | 240596 | 21178 | -91.2% | **11.36x** CharIndexing_japanese_unicodeScalars_Backwards | 136265 | 12032 | -91.2% | **11.33x** CharIndexing_chinese_unicodeScalars | 92226 | 8146 | -91.2% | **11.32x** CharIndexing_russian_unicodeScalars | 100908 | 8948 | -91.1% | **11.28x** CharIndexing_japanese_unicodeScalars | 145414 | 12895 | -91.1% | **11.28x** CharIndexing_ascii_unicodeScalars | 121438 | 10779 | -91.1% | **11.27x** CharIndexing_russian_unicodeScalars_Backwards | 94190 | 8367 | -91.1% | **11.26x** CharIndexing_korean_unicodeScalars_Backwards | 110175 | 9803 | -91.1% | **11.24x** CharIndexing_chinese_unicodeScalars_Backwards | 86479 | 7715 | -91.1% | **11.21x** CharIndexing_ascii_unicodeScalars_Backwards | 113255 | 10132 | -91.1% | **11.18x** CharIteration_ascii_unicodeScalars_Backwards | 114873 | 13701 | -88.1% | **8.38x** CharIteration_chinese_unicodeScalars_Backwards | 85778 | 10411 | -87.9% | **8.24x** CharIteration_russian_unicodeScalars_Backwards | 94504 | 11471 | -87.9% | **8.24x** CharIteration_japanese_unicodeScalars_Backwards | 136231 | 16569 | -87.8% | **8.22x** CharIteration_tweet_unicodeScalars_Backwards | 222907 | 27165 | -87.8% | **8.21x** CharIteration_korean_unicodeScalars_Backwards | 110132 | 13443 | -87.8% | **8.19x** CharIteration_korean_unicodeScalars | 79540 | 11859 | -85.1% | **6.71x** CharIteration_russian_unicodeScalars | 68209 | 10211 | -85.0% | **6.68x** CharIteration_japanese_unicodeScalars | 98016 | 14690 | -85.0% | **6.67x** CharIteration_tweet_unicodeScalars | 161177 | 24227 | -85.0% | **6.65x** CharIteration_chinese_unicodeScalars | 61702 | 9278 | -85.0% | **6.65x** CharIteration_ascii_unicodeScalars | 81049 | 12218 | -84.9% | **6.63x**
--- benchmark/single-source/StringWalk.swift | 392 +++++++++++++++++++ benchmark/single-source/StringWalk.swift.gyb | 54 +++ benchmark/utils/main.swift | 28 ++ 3 files changed, 474 insertions(+) diff --git a/benchmark/single-source/StringWalk.swift b/benchmark/single-source/StringWalk.swift index 5ae755f2bbb23..e55dad7e799a0 100644 --- a/benchmark/single-source/StringWalk.swift +++ b/benchmark/single-source/StringWalk.swift @@ -91,6 +91,7 @@ let unicodeScalarsMultiplier = baseMultiplier let charactersMultiplier = baseMultiplier / 5 + @inline(never) public func run_StringWalk_ascii_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -106,6 +107,8 @@ public func run_StringWalk_ascii_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_ascii_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -121,6 +124,60 @@ public func run_StringWalk_ascii_characters_Backwards(_ N: Int) { } + + +let asciiCharacters = Array(ascii) + +@inline(never) +public func run_CharIteration_ascii_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in asciiCharacters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_ascii_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in asciiCharacters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_ascii_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in asciiCharacters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_ascii_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in asciiCharacters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + + + @inline(never) public func run_StringWalk_utf16_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -136,6 +193,8 @@ public func run_StringWalk_utf16_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_utf16_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -151,6 +210,60 @@ public func run_StringWalk_utf16_characters_Backwards(_ N: Int) { } + + +let utf16Characters = Array(utf16) + +@inline(never) +public func run_CharIteration_utf16_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in utf16Characters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_utf16_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in utf16Characters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_utf16_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in utf16Characters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_utf16_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in utf16Characters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + + + @inline(never) public func run_StringWalk_tweet_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -166,6 +279,8 @@ public func run_StringWalk_tweet_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_tweet_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -181,6 +296,60 @@ public func run_StringWalk_tweet_characters_Backwards(_ N: Int) { } + + +let tweetCharacters = Array(tweet) + +@inline(never) +public func run_CharIteration_tweet_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in tweetCharacters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_tweet_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in tweetCharacters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_tweet_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in tweetCharacters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_tweet_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in tweetCharacters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + + + @inline(never) public func run_StringWalk_japanese_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -196,6 +365,8 @@ public func run_StringWalk_japanese_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_japanese_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -211,6 +382,60 @@ public func run_StringWalk_japanese_characters_Backwards(_ N: Int) { } + + +let japaneseCharacters = Array(japanese) + +@inline(never) +public func run_CharIteration_japanese_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in japaneseCharacters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_japanese_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in japaneseCharacters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_japanese_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in japaneseCharacters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_japanese_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in japaneseCharacters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + + + @inline(never) public func run_StringWalk_chinese_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -226,6 +451,8 @@ public func run_StringWalk_chinese_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_chinese_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -241,6 +468,60 @@ public func run_StringWalk_chinese_characters_Backwards(_ N: Int) { } + + +let chineseCharacters = Array(chinese) + +@inline(never) +public func run_CharIteration_chinese_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in chineseCharacters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_chinese_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in chineseCharacters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_chinese_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in chineseCharacters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_chinese_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in chineseCharacters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + + + @inline(never) public func run_StringWalk_korean_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -256,6 +537,8 @@ public func run_StringWalk_korean_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_korean_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -271,6 +554,60 @@ public func run_StringWalk_korean_characters_Backwards(_ N: Int) { } + + +let koreanCharacters = Array(korean) + +@inline(never) +public func run_CharIteration_korean_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in koreanCharacters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_korean_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in koreanCharacters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_korean_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in koreanCharacters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_korean_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in koreanCharacters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + + + @inline(never) public func run_StringWalk_russian_unicodeScalars(_ N: Int) { for _ in 1...unicodeScalarsMultiplier*N { @@ -286,6 +623,8 @@ public func run_StringWalk_russian_unicodeScalars_Backwards(_ N: Int) { } + + @inline(never) public func run_StringWalk_russian_characters(_ N: Int) { for _ in 1...charactersMultiplier*N { @@ -300,3 +639,56 @@ public func run_StringWalk_russian_characters_Backwards(_ N: Int) { } } + + + +let russianCharacters = Array(russian) + +@inline(never) +public func run_CharIteration_russian_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in russianCharacters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_russian_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in russianCharacters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_russian_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in russianCharacters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_russian_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in russianCharacters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + diff --git a/benchmark/single-source/StringWalk.swift.gyb b/benchmark/single-source/StringWalk.swift.gyb index 690d01b95ad31..a3e19130fcc8c 100644 --- a/benchmark/single-source/StringWalk.swift.gyb +++ b/benchmark/single-source/StringWalk.swift.gyb @@ -92,6 +92,7 @@ let unicodeScalarsMultiplier = baseMultiplier let charactersMultiplier = baseMultiplier / 5 % for Name in ["ascii", "utf16", "tweet", "japanese", "chinese", "korean", "russian"]: + % for Kind in ["unicodeScalars", "characters"]: @inline(never) @@ -108,5 +109,58 @@ public func run_StringWalk_${Name}_${Kind}_Backwards(_ N: Int) { } } + + % end + +let ${Name}Characters = Array(${Name}) + +@inline(never) +public func run_CharIteration_${Name}_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in ${Name}Characters { + for u in c.unicodeScalars { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIteration_${Name}_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in ${Name}Characters { + for u in c.unicodeScalars.reversed() { + count |= Int(u.value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_${Name}_unicodeScalars(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in ${Name}Characters { + let s = c.unicodeScalars + for i in s.indices { + count |= Int(s[i].value) + } + } + } +} + +@inline(never) +public func run_CharIndexing_${Name}_unicodeScalars_Backwards(_ N: Int) { + for _ in 1...unicodeScalarsMultiplier*N { + for c in ${Name}Characters { + let s = c.unicodeScalars + for i in s.indices.reversed() { + count |= Int(s[i].value) + } + } + } +} + + + % end diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift index 225b4c3fde760..18a0ad6dad864 100644 --- a/benchmark/utils/main.swift +++ b/benchmark/utils/main.swift @@ -170,6 +170,34 @@ addTo(&precommitTests, "CStringLongNonAscii", run_CStringLongNonAscii) addTo(&precommitTests, "CStringShortAscii", run_CStringShortAscii) addTo(&precommitTests, "Calculator", run_Calculator) addTo(&precommitTests, "CaptureProp", run_CaptureProp) +addTo(&precommitTests, "CharIndexing_ascii_unicodeScalars", run_CharIndexing_ascii_unicodeScalars) +addTo(&precommitTests, "CharIndexing_ascii_unicodeScalars_Backwards", run_CharIndexing_ascii_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIndexing_chinese_unicodeScalars", run_CharIndexing_chinese_unicodeScalars) +addTo(&precommitTests, "CharIndexing_chinese_unicodeScalars_Backwards", run_CharIndexing_chinese_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIndexing_japanese_unicodeScalars", run_CharIndexing_japanese_unicodeScalars) +addTo(&precommitTests, "CharIndexing_japanese_unicodeScalars_Backwards", run_CharIndexing_japanese_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIndexing_korean_unicodeScalars", run_CharIndexing_korean_unicodeScalars) +addTo(&precommitTests, "CharIndexing_korean_unicodeScalars_Backwards", run_CharIndexing_korean_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIndexing_russian_unicodeScalars", run_CharIndexing_russian_unicodeScalars) +addTo(&precommitTests, "CharIndexing_russian_unicodeScalars_Backwards", run_CharIndexing_russian_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIndexing_tweet_unicodeScalars", run_CharIndexing_tweet_unicodeScalars) +addTo(&precommitTests, "CharIndexing_tweet_unicodeScalars_Backwards", run_CharIndexing_tweet_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIndexing_utf16_unicodeScalars", run_CharIndexing_utf16_unicodeScalars) +addTo(&precommitTests, "CharIndexing_utf16_unicodeScalars_Backwards", run_CharIndexing_utf16_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_ascii_unicodeScalars", run_CharIteration_ascii_unicodeScalars) +addTo(&precommitTests, "CharIteration_ascii_unicodeScalars_Backwards", run_CharIteration_ascii_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_chinese_unicodeScalars", run_CharIteration_chinese_unicodeScalars) +addTo(&precommitTests, "CharIteration_chinese_unicodeScalars_Backwards", run_CharIteration_chinese_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_japanese_unicodeScalars", run_CharIteration_japanese_unicodeScalars) +addTo(&precommitTests, "CharIteration_japanese_unicodeScalars_Backwards", run_CharIteration_japanese_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_korean_unicodeScalars", run_CharIteration_korean_unicodeScalars) +addTo(&precommitTests, "CharIteration_korean_unicodeScalars_Backwards", run_CharIteration_korean_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_russian_unicodeScalars", run_CharIteration_russian_unicodeScalars) +addTo(&precommitTests, "CharIteration_russian_unicodeScalars_Backwards", run_CharIteration_russian_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_tweet_unicodeScalars", run_CharIteration_tweet_unicodeScalars) +addTo(&precommitTests, "CharIteration_tweet_unicodeScalars_Backwards", run_CharIteration_tweet_unicodeScalars_Backwards) +addTo(&precommitTests, "CharIteration_utf16_unicodeScalars", run_CharIteration_utf16_unicodeScalars) +addTo(&precommitTests, "CharIteration_utf16_unicodeScalars_Backwards", run_CharIteration_utf16_unicodeScalars_Backwards) addTo(&precommitTests, "CharacterLiteralsLarge", run_CharacterLiteralsLarge) addTo(&precommitTests, "CharacterLiteralsSmall", run_CharacterLiteralsSmall) addTo(&precommitTests, "Chars", run_Chars)