[benchmark] More StringBuilder and improvements

Author: milseman

benchmark/single-source/StringBuilder.swift

@@ -13,10 +13,30 @@
 import TestsUtils
 
 public let StringBuilder = [
-  BenchmarkInfo(name: "StringAdder", runFunction: run_StringAdder, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "StringBuilder", runFunction: run_StringBuilder, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "StringBuilderLong", runFunction: run_StringBuilderLong, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "StringUTF16Builder", runFunction: run_StringUTF16Builder, tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringAdder",
+    runFunction: run_StringAdder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringBuilder",
+    runFunction: run_StringBuilder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringUTF16Builder",
+    runFunction: run_StringUTF16Builder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringUTF16SubstringBuilder",
+    runFunction: run_StringUTF16SubstringBuilder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringBuilderLong",
+    runFunction: run_StringBuilderLong,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringBuilderWithLongSubstring",
+    runFunction: run_StringBuilderWithLongSubstring,
+    tags: [.validation, .api, .String]),
   BenchmarkInfo(
     name: "StringWordBuilder",
     runFunction: run_StringWordBuilder,
@@ -29,7 +49,7 @@ public let StringBuilder = [
 
 @inline(never)
 func buildString(_ i: String) -> String {
-  var sb = i
+  var sb = getString(i)
   for str in ["b","c","d","pizza"] {
     sb += str
   }
@@ -39,54 +59,95 @@ func buildString(_ i: String) -> String {
 @inline(never)
 public func run_StringBuilder(_ N: Int) {
   for _ in 1...5000*N {
-    _ = buildString(getString("a"))
+    blackHole(buildString("a"))
   }
 }
 
 @inline(never)
 func addString(_ i: String) -> String {
-  let s = i + "b" + "c" + "d" + "pizza"
+  let s = getString(i) + "b" + "c" + "d" + "pizza"
   return s
 }
 
 @inline(never)
 public func run_StringAdder(_ N: Int) {
   for _ in 1...5000*N {
-    _ = addString(getString("a"))
+    blackHole(addString("a"))
   }
 }
 
 @inline(never)
 func buildStringUTF16(_ i: String) -> String {
-  var sb = i
+  var sb = getString(i)
   for str in ["🎉","c","d","pizza"] {
     sb += str
   }
   return sb
 }
 
+@inline(never)
+func buildStringFromSmallSubstrings(_ i: String) -> String {
+  var sb = getString(i)
+  for str in ["_🎉","cd","de","pizza"] {
+    sb += str.dropFirst()
+  }
+  return sb
+}
+
 @inline(never)
 public func run_StringUTF16Builder(_ N: Int) {
   for _ in 1...5000*N {
-    _ = buildStringUTF16("a")
+    blackHole(buildStringUTF16("a"))
+  }
+}
+
+@inline(never)
+public func run_StringUTF16SubstringBuilder(_ N: Int) {
+  for _ in 1...5000*N {
+    blackHole(buildStringFromSmallSubstrings("a"))
   }
 }
 
+func getLongString() -> String {
+  let long = """
+    Swift is a multi-paradigm, compiled programming language created for
+     iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is
+     designed to work with Apple's Cocoa and Cocoa Touch frameworks and the
+     large body of existing Objective-C code written for Apple products. Swift
+     is intended to be more resilient to erroneous code (\"safer\") than
+     Objective-C and also more concise. It is built with the LLVM compiler
+     framework included in Xcode 6 and later and uses the Objective-C runtime,
+     which allows C, Objective-C, C++ and Swift code to run within a single
+     program.
+    """
+  return getString(long)
+}
 
 @inline(never)
 func buildStringLong(_ i: String) -> String {
-  var sb = i
-  let long = "Swift is a multi-paradigm, compiled programming language created for iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C code written for Apple products. Swift is intended to be more resilient to erroneous code (\"safer\") than Objective-C and also more concise. It is built with the LLVM compiler framework included in Xcode 6 and later and uses the Objective-C runtime, which allows C, Objective-C, C++ and Swift code to run within a single program."
-  sb += long
+  var sb = getString(i)
+  sb += getLongString()
   return sb
 }
 
-
+@inline(never)
+func buildStringWithLongSubstring(_ i: String) -> String {
+  var sb = getString(i)
+  sb += getLongString().dropFirst()
+  return sb
+}
 
 @inline(never)
 public func run_StringBuilderLong(_ N: Int) {
   for _ in 1...5000*N {
-    _ = buildStringLong("👻")
+    blackHole(buildStringLong("👻"))
+  }
+}
+
+@inline(never)
+public func run_StringBuilderWithLongSubstring(_ N: Int) {
+  for _ in 1...5000*N {
+    blackHole(buildStringWithLongSubstring("👻"))
   }
 }
 
@@ -96,6 +157,7 @@ func buildString(
   count: Int,
   reservingCapacity: Bool
 ) -> String {
+  let word = getString(word)
   var sb = ""
   if reservingCapacity {
     sb.reserveCapacity(count * word.unicodeScalars.count)
@@ -108,10 +170,12 @@ func buildString(
 
 @inline(never)
 public func run_StringWordBuilder(_ N: Int) {
-  _ = buildString(word: "bumfuzzle", count: 50_000 * N, reservingCapacity: false)
+  blackHole(buildString(
+    word: "bumfuzzle", count: 50_000 * N, reservingCapacity: false))
 }
 
 @inline(never)
 public func run_StringWordBuilderReservingCapacity(_ N: Int) {
-  _ = buildString(word: "bumfuzzle", count: 50_000 * N, reservingCapacity: true)
+  blackHole(buildString(
+    word: "bumfuzzle", count: 50_000 * N, reservingCapacity: true))
 }