diff --git a/benchmark/single-source/ArrayAppend.swift b/benchmark/single-source/ArrayAppend.swift
index 633d81eee297c..4e674271be023 100644
--- a/benchmark/single-source/ArrayAppend.swift
+++ b/benchmark/single-source/ArrayAppend.swift
@@ -14,31 +14,53 @@
 
 import TestsUtils
 
+let t: [BenchmarkCategory] = [.validation, .api, .Array]
 public let ArrayAppend = [
-  BenchmarkInfo(name: "ArrayAppend", runFunction: run_ArrayAppend, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendArrayOfInt", runFunction: run_ArrayAppendArrayOfInt, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendAscii", runFunction: run_ArrayAppendAscii, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendAsciiSubstring", runFunction: run_ArrayAppendAsciiSubstring, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendFromGeneric", runFunction: run_ArrayAppendFromGeneric, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendGenericStructs", runFunction: run_ArrayAppendGenericStructs, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendLatin1", runFunction: run_ArrayAppendLatin1, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendLatin1Substring", runFunction: run_ArrayAppendLatin1Substring, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendLazyMap", runFunction: run_ArrayAppendLazyMap, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendOptionals", runFunction: run_ArrayAppendOptionals, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendRepeatCol", runFunction: run_ArrayAppendRepeatCol, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendReserved", runFunction: run_ArrayAppendReserved, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendSequence", runFunction: run_ArrayAppendSequence, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendStrings", runFunction: run_ArrayAppendStrings, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendToFromGeneric", runFunction: run_ArrayAppendToFromGeneric, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendToGeneric", runFunction: run_ArrayAppendToGeneric, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendUTF16", runFunction: run_ArrayAppendUTF16, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayAppendUTF16Substring", runFunction: run_ArrayAppendUTF16Substring, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayPlusEqualArrayOfInt", runFunction: run_ArrayPlusEqualArrayOfInt, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayPlusEqualFiveElementCollection", runFunction: run_ArrayPlusEqualFiveElementCollection, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayPlusEqualSingleElementCollection", runFunction: run_ArrayPlusEqualSingleElementCollection, tags: [.validation, .api, .Array]),
-  BenchmarkInfo(name: "ArrayPlusEqualThreeElements", runFunction: run_ArrayPlusEqualThreeElements, tags: [.validation, .api, .Array]),
+  BenchmarkInfo(name: "ArrayAppend", runFunction: run_ArrayAppend, tags: t),
+  BenchmarkInfo(name: "ArrayAppendArrayOfInt", runFunction: run_ArrayAppendArrayOfInt, tags: t,
+    setUpFunction: ones, tearDownFunction: releaseOnes),
+  BenchmarkInfo(name: "ArrayAppendAscii", runFunction: run_ArrayAppendAscii, tags: t),
+  BenchmarkInfo(name: "ArrayAppendAsciiSubstring", runFunction: run_ArrayAppendAsciiSubstring, tags: t),
+  BenchmarkInfo(name: "ArrayAppendFromGeneric", runFunction: run_ArrayAppendFromGeneric, tags: t,
+    setUpFunction: ones, tearDownFunction: releaseOnes),
+  BenchmarkInfo(name: "ArrayAppendGenericStructs", runFunction: run_ArrayAppendGenericStructs, tags: t,
+    setUpFunction: { otherStructs = Array(repeating: S(x: 3, y: 4.2), count: 10_000) },
+    tearDownFunction: {  otherStructs = nil } ),
+  BenchmarkInfo(name: "ArrayAppendLatin1", runFunction: run_ArrayAppendLatin1, tags: t),
+  BenchmarkInfo(name: "ArrayAppendLatin1Substring", runFunction: run_ArrayAppendLatin1Substring, tags: t),
+  BenchmarkInfo(name: "ArrayAppendLazyMap", runFunction: run_ArrayAppendLazyMap, tags: t,
+    setUpFunction: { blackHole(array) }),
+  BenchmarkInfo(name: "ArrayAppendOptionals", runFunction: run_ArrayAppendOptionals, tags: t,
+    setUpFunction: { otherOptionalOnes = Array(repeating: 1, count: 10_000) },
+    tearDownFunction: {  otherOptionalOnes = nil } ),
+  BenchmarkInfo(name: "ArrayAppendRepeatCol", runFunction: run_ArrayAppendRepeatCol, tags: t),
+  BenchmarkInfo(name: "ArrayAppendReserved", runFunction: run_ArrayAppendReserved, tags: t),
+  BenchmarkInfo(name: "ArrayAppendSequence", runFunction: run_ArrayAppendSequence, tags: t),
+  BenchmarkInfo(name: "ArrayAppendStrings", runFunction: run_ArrayAppendStrings, tags: t,
+    setUpFunction: { otherStrings = stride(from: 0, to: 10_000, by: 1).map { "\($0)" } },
+    tearDownFunction: {  otherStrings = nil } ),
+  BenchmarkInfo(name: "ArrayAppendToFromGeneric", runFunction: run_ArrayAppendToFromGeneric, tags: t,
+    setUpFunction: ones, tearDownFunction: releaseOnes),
+  BenchmarkInfo(name: "ArrayAppendToGeneric", runFunction: run_ArrayAppendToGeneric, tags: t,
+    setUpFunction: ones, tearDownFunction: releaseOnes),
+  BenchmarkInfo(name: "ArrayAppendUTF16", runFunction: run_ArrayAppendUTF16, tags: t),
+  BenchmarkInfo(name: "ArrayAppendUTF16Substring", runFunction: run_ArrayAppendUTF16Substring, tags: t),
+  BenchmarkInfo(name: "ArrayPlusEqualArrayOfInt", runFunction: run_ArrayPlusEqualArrayOfInt, tags: t,
+    setUpFunction: ones, tearDownFunction: releaseOnes),
+  BenchmarkInfo(name: "ArrayPlusEqualFiveElementCollection", runFunction: run_ArrayPlusEqualFiveElementCollection, tags: t),
+  BenchmarkInfo(name: "ArrayPlusEqualSingleElementCollection", runFunction: run_ArrayPlusEqualSingleElementCollection, tags: t),
+  BenchmarkInfo(name: "ArrayPlusEqualThreeElements", runFunction: run_ArrayPlusEqualThreeElements, tags: t),
 ]
 
+var otherOnes: [Int]!
+var otherOptionalOnes: [Int?]!
+var otherStrings: [String]!
+var otherStructs: [S<Int, Double>]!
+let array = Array(0..<10_000)
+
+func ones() { otherOnes = Array(repeating: 1, count: 10_000) }
+func releaseOnes() { otherOnes = nil }
+
 // Append single element
 @inline(never)
 public func run_ArrayAppend(_ N: Int) {
@@ -67,10 +89,11 @@ public func run_ArrayAppendReserved(_ N: Int) {
 }
 
 // Append a sequence. Length of sequence unknown so
-// can't pre-reserve capacity. 
+// can't pre-reserve capacity.
 @inline(never)
 public func run_ArrayAppendSequence(_ N: Int) {
   let seq = stride(from: 0, to: 10_000, by: 1)
+
   for _ in 0..<N {
     for _ in 0..<10 {
       var nums = [Int]()
@@ -85,7 +108,8 @@ public func run_ArrayAppendSequence(_ N: Int) {
 // can pre-reserve capacity.
 @inline(never)
 public func run_ArrayAppendArrayOfInt(_ N: Int) {
-  let other = Array(repeating: 1, count: 10_000)
+  let other: [Int] = otherOnes
+
   for _ in 0..<N {
     for _ in 0..<10 {
       var nums = [Int]()
@@ -100,7 +124,8 @@ public func run_ArrayAppendArrayOfInt(_ N: Int) {
 // except +=, to check equally performant.
 @inline(never)
 public func run_ArrayPlusEqualArrayOfInt(_ N: Int) {
-  let other = Array(repeating: 1, count: 10_000)
+  let other: [Int] = otherOnes
+
   for _ in 0..<N {
     for _ in 0..<10 {
       var nums = [Int]()
@@ -115,7 +140,8 @@ public func run_ArrayPlusEqualArrayOfInt(_ N: Int) {
 // can pre-reserve capacity.
 @inline(never)
 public func run_ArrayAppendStrings(_ N: Int) {
-  let other = stride(from: 0, to: 10_000, by: 1).map { "\($0)" }
+  let other: [String] = otherStrings
+
   for _ in 0..<N {
     for _ in 0..<10 {
       var nums = [String]()
@@ -136,10 +162,11 @@ struct S<T,U> {
 // can pre-reserve capacity.
 @inline(never)
 public func run_ArrayAppendGenericStructs(_ N: Int) {
-  let other = Array(repeating: S(x: 3, y: 4.2), count: 10_000)
+  let other: [S<Int, Double>] = otherStructs
+
   for _ in 0..<N {
     for _ in 0..<10 {
-      var nums = [S<Int,Double>]()
+      var nums = [S<Int, Double>]()
       for _ in 0..<8 {
         nums += other
       }
@@ -151,7 +178,7 @@ public func run_ArrayAppendGenericStructs(_ N: Int) {
 // can pre-reserve capacity.
 @inline(never)
 public func run_ArrayAppendOptionals(_ N: Int) {
-  let other: [Int?] = Array(repeating: 1, count: 10_000)
+  let other: [Int?] = otherOptionalOnes
 
   for _ in 0..<N {
     for _ in 0..<10 {
@@ -168,7 +195,7 @@ public func run_ArrayAppendOptionals(_ N: Int) {
 // can pre-reserve capacity, but no optimization points used.
 @inline(never)
 public func run_ArrayAppendLazyMap(_ N: Int) {
-  let other = Array(0..<10_000).lazy.map { $0 * 2 }
+  let other = array.lazy.map { $0 * 2 }
 
   for _ in 0..<N {
     for _ in 0..<10 {
@@ -208,7 +235,7 @@ public func appendFromGeneric<
 
 @inline(never)
 public func run_ArrayAppendFromGeneric(_ N: Int) {
-  let other = Array(repeating: 1, count: 10_000)
+  let other: [Int] = otherOnes
 
   for _ in 0..<N {
     for _ in 0..<10 {
@@ -230,7 +257,7 @@ public func appendToGeneric<
 
 @inline(never)
 public func run_ArrayAppendToGeneric(_ N: Int) {
-  let other = Array(repeating: 1, count: 10_000)
+  let other: [Int] = otherOnes
 
   for _ in 0..<N {
     for _ in 0..<10 {
@@ -247,14 +274,14 @@ public func run_ArrayAppendToGeneric(_ N: Int) {
 @inline(never)
 public func appendToFromGeneric<
   R: RangeReplaceableCollection, S: Sequence
->(collection: inout R, sequence: S) 
+>(collection: inout R, sequence: S)
 where R.Element == S.Element {
   collection.append(contentsOf: sequence)
 }
 
 @inline(never)
 public func run_ArrayAppendToFromGeneric(_ N: Int) {
-  let other = Array(repeating: 1, count: 10_000)
+  let other: [Int] = otherOnes
 
   for _ in 0..<N {
     for _ in 0..<10 {
@@ -319,7 +346,7 @@ public func run_ArrayAppendAscii(_ N: Int) {
   }
 }
 
-// Append the utf8 elements of an ascii string to a [UInt8]
+// Append the utf8 elements of a latin1 string to a [UInt8]
 @inline(never)
 public func run_ArrayAppendLatin1(_ N: Int) {
   let s = "the quick brown fox jumps over the lazy dog\u{00A1}"
@@ -333,7 +360,7 @@ public func run_ArrayAppendLatin1(_ N: Int) {
   }
 }
 
-// Append the utf8 elements of an ascii string to a [UInt8]
+// Append the utf8 elements of an utf16 string to a [UInt8]
 @inline(never)
 public func run_ArrayAppendUTF16(_ N: Int) {
   let s = "the quick brown 🦊 jumps over the lazy dog"
@@ -347,7 +374,7 @@ public func run_ArrayAppendUTF16(_ N: Int) {
   }
 }
 
-// Append the utf8 elements of an ascii string to a [UInt8]
+// Append the utf8 elements of an ascii substring to a [UInt8]
 @inline(never)
 public func run_ArrayAppendAsciiSubstring(_ N: Int) {
   let s = "the quick brown fox jumps over the lazy dog!"[...]
@@ -361,7 +388,7 @@ public func run_ArrayAppendAsciiSubstring(_ N: Int) {
   }
 }
 
-// Append the utf8 elements of an ascii string to a [UInt8]
+// Append the utf8 elements of a latin1 substring to a [UInt8]
 @inline(never)
 public func run_ArrayAppendLatin1Substring(_ N: Int) {
   let s = "the quick brown fox jumps over the lazy dog\u{00A1}"[...]
@@ -375,7 +402,7 @@ public func run_ArrayAppendLatin1Substring(_ N: Int) {
   }
 }
 
-// Append the utf8 elements of an ascii string to a [UInt8]
+// Append the utf8 elements of an utf16 substring to a [UInt8]
 @inline(never)
 public func run_ArrayAppendUTF16Substring(_ N: Int) {
   let s = "the quick brown 🦊 jumps over the lazy dog"[...]
@@ -388,4 +415,3 @@ public func run_ArrayAppendUTF16Substring(_ N: Int) {
     }
   }
 }
-
diff --git a/benchmark/single-source/ArrayInClass.swift b/benchmark/single-source/ArrayInClass.swift
index 1f064a1828894..3aa94d0111905 100644
--- a/benchmark/single-source/ArrayInClass.swift
+++ b/benchmark/single-source/ArrayInClass.swift
@@ -14,7 +14,11 @@ import TestsUtils
 public let ArrayInClass = BenchmarkInfo(
   name: "ArrayInClass",
   runFunction: run_ArrayInClass,
-  tags: [.validation, .api, .Array])
+  tags: [.validation, .api, .Array],
+  setUpFunction: { ac = ArrayContainer() },
+  tearDownFunction: { ac = nil })
+
+var ac: ArrayContainer!
 
 class ArrayContainer {
   final var arr : [Int]
@@ -32,13 +36,8 @@ class ArrayContainer {
   }
 }
 
-@inline(never)
-func getArrayContainer() -> ArrayContainer {
-  return ArrayContainer()
-}
-
 @inline(never)
 public func run_ArrayInClass(_ N: Int) {
-  let a = getArrayContainer()
+  let a = ac!
   a.runLoop(N)
 }
diff --git a/benchmark/single-source/DataBenchmarks.swift b/benchmark/single-source/DataBenchmarks.swift
index 46b90ffc22e21..02c79fd52a7fd 100644
--- a/benchmark/single-source/DataBenchmarks.swift
+++ b/benchmark/single-source/DataBenchmarks.swift
@@ -41,6 +41,9 @@ public let DataBenchmarks = [
     BenchmarkInfo(name: "DataAppendDataLargeToLarge", runFunction: run_AppendDataLargeToLarge, tags: [.validation, .api, .Data]),
 ]
 
+let small = sampleData(.small)
+let medium = sampleData(.medium)
+
 enum SampleKind {
     case small
     case medium
@@ -138,7 +141,6 @@ func sampleData(_ type: SampleKind) -> Data {
     case .string: return sampleString()
     case .immutableBacking: return sampleBridgedNSData()
     }
-    
 }
 
 func benchmark_AccessBytes(_ N: Int, _ data: Data) {
@@ -228,7 +230,7 @@ func benchmark_AppendData(_ N: Int, _ lhs: Data, _ rhs: Data) {
 
 @inline(never)
 public func run_Subscript(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     let index = 521
     for _ in 1...10000*N {
         // Ensure that the compiler does not optimize away this call
@@ -238,7 +240,7 @@ public func run_Subscript(_ N: Int) {
 
 @inline(never)
 public func run_Count(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     for _ in 1...10000*N {
         // Ensure that the compiler does not optimize away this call
         blackHole(data.count)
@@ -247,7 +249,7 @@ public func run_Count(_ N: Int) {
 
 @inline(never)
 public func run_SetCount(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     let count = data.count + 100
     var otherData = data
     let orig = data.count
@@ -259,65 +261,65 @@ public func run_SetCount(_ N: Int) {
 
 @inline(never)
 public func run_AccessBytes(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_AccessBytes(N, data)
 }
 
 @inline(never)
 public func run_MutateBytes(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_MutateBytes(N, data)
 }
 
 @inline(never)
 public func run_CopyBytes(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_CopyBytes(N, data)
 }
 
 @inline(never)
 public func run_AppendBytes(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_AppendBytes(N, 809, data)
 }
 
 @inline(never)
 public func run_AppendArray(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_AppendArray(N, 809, data)
 }
 
 @inline(never)
 public func run_Reset(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_Reset(N, 431..<809, data)
 }
 
 @inline(never)
 public func run_ReplaceSmall(_ N: Int) {
-    let data = sampleData(.medium)
-    let replacement = sampleData(.small)
+    let data = medium
+    let replacement = small
     benchmark_Replace(N, 431..<809, data, replacement)
 }
 
 @inline(never)
 public func run_ReplaceMedium(_ N: Int) {
-    let data = sampleData(.medium)
-    let replacement = sampleData(.medium)
+    let data = medium
+    let replacement = medium
     benchmark_Replace(N, 431..<809, data, replacement)
 }
 
 @inline(never)
 public func run_ReplaceLarge(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     let replacement = sampleData(.large)
     benchmark_Replace(N, 431..<809, data, replacement)
 }
 
 @inline(never)
 public func run_ReplaceSmallBuffer(_ N: Int) {
-    let data = sampleData(.medium)
-    let replacement = sampleData(.small)
+    let data = medium
+    let replacement = small
     let sz = replacement.count
     replacement.withUnsafeBytes { (ptr: UnsafePointer<UInt8>) in
         benchmark_ReplaceBuffer(N, 431..<809, data, UnsafeBufferPointer(start: ptr, count: sz))
@@ -326,8 +328,8 @@ public func run_ReplaceSmallBuffer(_ N: Int) {
 
 @inline(never)
 public func run_ReplaceMediumBuffer(_ N: Int) {
-    let data = sampleData(.medium)
-    let replacement = sampleData(.medium)
+    let data = medium
+    let replacement = medium
     let sz = replacement.count
     replacement.withUnsafeBytes { (ptr: UnsafePointer<UInt8>) in
         benchmark_ReplaceBuffer(N, 431..<809, data, UnsafeBufferPointer(start: ptr, count: sz))
@@ -336,7 +338,7 @@ public func run_ReplaceMediumBuffer(_ N: Int) {
 
 @inline(never)
 public func run_ReplaceLargeBuffer(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     let replacement = sampleData(.large)
     let sz = replacement.count
     replacement.withUnsafeBytes { (ptr: UnsafePointer<UInt8>) in
@@ -346,62 +348,62 @@ public func run_ReplaceLargeBuffer(_ N: Int) {
 
 @inline(never)
 public func run_AppendSequence(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     benchmark_AppendSequence(N, 809, data)
 }
 
 @inline(never)
 public func run_AppendDataSmallToSmall(_ N: Int) {
-    let data = sampleData(.small)
-    let other = sampleData(.small)
+    let data = small
+    let other = small
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataSmallToMedium(_ N: Int) {
-    let data = sampleData(.medium)
-    let other = sampleData(.small)
+    let data = medium
+    let other = small
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataSmallToLarge(_ N: Int) {
     let data = sampleData(.large)
-    let other = sampleData(.small)
+    let other = small
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataMediumToSmall(_ N: Int) {
-    let data = sampleData(.small)
-    let other = sampleData(.medium)
+    let data = small
+    let other = medium
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataMediumToMedium(_ N: Int) {
-    let data = sampleData(.medium)
-    let other = sampleData(.medium)
+    let data = medium
+    let other = medium
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataMediumToLarge(_ N: Int) {
     let data = sampleData(.large)
-    let other = sampleData(.medium)
+    let other = medium
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataLargeToSmall(_ N: Int) {
-    let data = sampleData(.small)
+    let data = small
     let other = sampleData(.large)
     benchmark_AppendData(N, data, other)
 }
 
 @inline(never)
 public func run_AppendDataLargeToMedium(_ N: Int) {
-    let data = sampleData(.medium)
+    let data = medium
     let other = sampleData(.large)
     benchmark_AppendData(N, data, other)
 }
diff --git a/benchmark/single-source/DictTest.swift b/benchmark/single-source/DictTest.swift
index bf4f10e60fab3..e730bdad8234e 100644
--- a/benchmark/single-source/DictTest.swift
+++ b/benchmark/single-source/DictTest.swift
@@ -14,13 +14,16 @@ import TestsUtils
 
 
 public let Dictionary = [
-  BenchmarkInfo(name: "Dictionary", runFunction: run_Dictionary, tags: [.validation, .api, .Dictionary]),
-  BenchmarkInfo(name: "DictionaryOfObjects", runFunction: run_DictionaryOfObjects, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(name: "Dictionary", runFunction: run_Dictionary,
+    tags: [.validation, .api, .Dictionary],
+    setUpFunction: { blackHole(half) }),
+  BenchmarkInfo(name: "DictionaryOfObjects",
+    runFunction: run_DictionaryOfObjects,
+    tags: [.validation, .api, .Dictionary],
+    setUpFunction: { blackHole(halfObjects) }),
 ]
 
-@inline(never)
-public func run_Dictionary(scale: Int) {
-  let Input = [
+let text = [
     // Text from http://en.wikipedia.org/wiki/Hash_table
     "hash", "table",
       "in", "computing", "a", "hash", "table", "also", "hash", "map", "is",
@@ -118,31 +121,37 @@ public func run_Dictionary(scale: Int) {
       "entries", "for", "some", "sets", "of", "keys"
   ]
 
-  var Dict: Dictionary<String, Bool> = [:]
+// Fill the dictionary with words from the first half of the text
+let half: Dictionary<String, Bool> = {
+  var dict: Dictionary<String, Bool> = [:]
+  for i in 0 ..< text.count/2 {
+    let word = text[i]
+    dict[word] = true
+  }
+  return dict
+}()
+
+@inline(never)
+public func run_Dictionary(scale: Int) {
+  var dict: Dictionary<String, Bool> = [:]
   let N = 5*scale
 
   // Check performance of filling the dictionary:
   for _ in 1...N {
-    Dict = [:]
-    for word in Input {
-      Dict[word] = true
+    dict = [:]
+    for word in text {
+      dict[word] = true
     }
   }
-  CheckResults(Dict.count == 270)
+  CheckResults(dict.count == 270)
 
   // Check performance of searching in the dictionary:
-  // Fill the dictionary with words from the first half of the text
-  Dict = [:]
-  for i in 0 ..< Input.count/2 {
-    let word = Input[i]
-    Dict[word] = true
-  }
-
+  dict = half
   // Count number of words from the first half in the entire text
   var count = 0
   for _ in 1...N {
-    for word in Input {
-      if Dict[word] != nil {
+    for word in text {
+      if dict[word] != nil {
         count += 1
       }
     }
@@ -166,131 +175,37 @@ class Box<T : Hashable> : Hashable {
   }
 }
 
+// Fill the dictionary with words from the first half of the text
+let halfObjects: Dictionary<Box<String>, Box<Bool>> = {
+  var dict: Dictionary<Box<String>, Box<Bool>> = [:]
+  for i in 0 ..< text.count/2 {
+    let word = text[i]
+    dict[Box(word)] = Box(true)
+  }
+  return dict
+}()
+
 @inline(never)
 public func run_DictionaryOfObjects(scale: Int) {
-  let Input = [
-    // Text from http://en.wikipedia.org/wiki/Hash_table
-    "hash", "table",
-      "in", "computing", "a", "hash", "table", "also", "hash", "map", "is",
-      "a", "data", "structure", "used", "to", "implement", "an", "associative",
-      "array", "a", "structure", "that", "can", "map", "keys", "to", "values",
-      "a", "hash", "table", "uses", "a", "hash", "function", "to", "compute",
-      "an", "index", "into", "an", "array", "of", "buckets", "or", "slots",
-      "from", "which", "the", "correct", "value", "can", "be", "found",
-      "ideally", "the", "hash", "function", "will", "assign", "each", "key",
-      "to", "a", "unique", "bucket", "but", "this", "situation", "is",
-      "rarely", "achievable", "in", "practice", "usually", "some", "keys",
-      "will", "hash", "to", "the", "same", "bucket", "instead", "most", "hash",
-      "table", "designs", "assume", "that", "hash", "collisions", "different",
-      "keys", "that", "are", "assigned", "by", "the", "hash", "function", "to",
-      "the", "same", "bucket", "will", "occur", "and", "must", "be",
-      "accommodated", "in", "some", "way", "in", "a", "well", "dimensioned",
-      "hash", "table", "the", "average", "cost", "number", "of",
-      "instructions", "for", "each", "lookup", "is", "independent", "of",
-      "the", "number", "of", "elements", "stored", "in", "the", "table",
-      "many", "hash", "table", "designs", "also", "allow", "arbitrary",
-      "insertions", "and", "deletions", "of", "key", "value", "pairs", "at",
-      "amortized", "constant", "average", "cost", "per", "operation", "in",
-      "many", "situations", "hash", "tables", "turn", "out", "to", "be",
-      "more", "efficient", "than", "search", "trees", "or", "any", "other",
-      "table", "lookup", "structure", "for", "this", "reason", "they", "are",
-      "widely", "used", "in", "many", "kinds", "of", "computer", "software",
-      "particularly", "for", "associative", "arrays", "database", "indexing",
-      "caches", "and", "sets",
-
-    "hashing",
-      "the", "idea", "of", "hashing", "is", "to", "distribute", "the",
-      "entries", "key", "value", "pairs", "across", "an", "array", "of",
-      "buckets", "given", "a", "key", "the", "algorithm", "computes", "an",
-      "index", "that", "suggests", "where", "the", "entry", "can", "be",
-      "found", "index", "f", "key", "array", "size", "often", "this", "is",
-      "done", "in", "two", "steps", "hash", "hashfunc", "key", "index", "hash",
-      "array", "size", "in", "this", "method", "the", "hash", "is",
-      "independent", "of", "the", "array", "size", "and", "it", "is", "then",
-      "reduced", "to", "an", "index", "a", "number", "between", "and", "array",
-      "size", "using", "the", "modulus", "operator", "in", "the", "case",
-      "that", "the", "array", "size", "is", "a", "power", "of", "two", "the",
-      "remainder", "operation", "is", "reduced", "to", "masking", "which",
-      "improves", "speed", "but", "can", "increase", "problems", "with", "a",
-      "poor", "hash", "function",
-
-    "choosing", "a", "good", "hash", "function",
-      "a", "good", "hash", "function", "and", "implementation", "algorithm",
-      "are", "essential", "for", "good", "hash", "table", "performance", "but",
-      "may", "be", "difficult", "to", "achieve", "a", "basic", "requirement",
-      "is", "that", "the", "function", "should", "provide", "a", "uniform",
-      "distribution", "of", "hash", "values", "a", "non", "uniform",
-      "distribution", "increases", "the", "number", "of", "collisions", "and",
-      "the", "cost", "of", "resolving", "them", "uniformity", "is",
-      "sometimes", "difficult", "to", "ensure", "by", "design", "but", "may",
-      "be", "evaluated", "empirically", "using", "statistical", "tests", "e",
-      "g", "a", "pearson", "s", "chi", "squared", "test", "for", "discrete",
-      "uniform", "distributions", "the", "distribution", "needs", "to", "be",
-      "uniform", "only", "for", "table", "sizes", "that", "occur", "in", "the",
-      "application", "in", "particular", "if", "one", "uses", "dynamic",
-      "resizing", "with", "exact", "doubling", "and", "halving", "of", "the",
-      "table", "size", "s", "then", "the", "hash", "function", "needs", "to",
-      "be", "uniform", "only", "when", "s", "is", "a", "power", "of", "two",
-      "on", "the", "other", "hand", "some", "hashing", "algorithms", "provide",
-      "uniform", "hashes", "only", "when", "s", "is", "a", "prime", "number",
-      "for", "open", "addressing", "schemes", "the", "hash", "function",
-      "should", "also", "avoid", "clustering", "the", "mapping", "of", "two",
-      "or", "more", "keys", "to", "consecutive", "slots", "such", "clustering",
-      "may", "cause", "the", "lookup", "cost", "to", "skyrocket", "even", "if",
-      "the", "load", "factor", "is", "low", "and", "collisions", "are",
-      "infrequent", "the", "popular", "multiplicative", "hash", "3", "is",
-      "claimed", "to", "have", "particularly", "poor", "clustering",
-      "behavior", "cryptographic", "hash", "functions", "are", "believed",
-      "to", "provide", "good", "hash", "functions", "for", "any", "table",
-      "size", "s", "either", "by", "modulo", "reduction", "or", "by", "bit",
-      "masking", "they", "may", "also", "be", "appropriate", "if", "there",
-      "is", "a", "risk", "of", "malicious", "users", "trying", "to",
-      "sabotage", "a", "network", "service", "by", "submitting", "requests",
-      "designed", "to", "generate", "a", "large", "number", "of", "collisions",
-      "in", "the", "server", "s", "hash", "tables", "however", "the", "risk",
-      "of", "sabotage", "can", "also", "be", "avoided", "by", "cheaper",
-      "methods", "such", "as", "applying", "a", "secret", "salt", "to", "the",
-      "data", "or", "using", "a", "universal", "hash", "function",
-
-    "perfect", "hash", "function",
-      "if", "all", "keys", "are", "known", "ahead", "of", "time", "a",
-      "perfect", "hash", "function", "can", "be", "used", "to", "create", "a",
-      "perfect", "hash", "table", "that", "has", "no", "collisions", "if",
-      "minimal", "perfect", "hashing", "is", "used", "every", "location", "in",
-      "the", "hash", "table", "can", "be", "used", "as", "well", "perfect",
-      "hashing", "allows", "for", "constant", "time", "lookups", "in", "the",
-      "worst", "case", "this", "is", "in", "contrast", "to", "most",
-      "chaining", "and", "open", "addressing", "methods", "where", "the",
-      "time", "for", "lookup", "is", "low", "on", "average", "but", "may",
-      "be", "very", "large", "proportional", "to", "the", "number", "of",
-      "entries", "for", "some", "sets", "of", "keys"
-  ]
-
-  var Dict: Dictionary<Box<String>, Box<Bool>> = [:]
+  var dict: Dictionary<Box<String>, Box<Bool>> = [:]
   let N = 5*scale
 
   // Check performance of filling the dictionary:
   for _ in 1...N {
-    Dict = [:]
-    for word in Input {
-      Dict[Box(word)] = Box(true)
+    dict = [:]
+    for word in text {
+      dict[Box(word)] = Box(true)
     }
   }
-  CheckResults(Dict.count == 270)
+  CheckResults(dict.count == 270)
 
   // Check performance of searching in the dictionary:
-  // Fill the dictionary with words from the first half of the text
-  Dict = [:]
-  for i in 0 ..< Input.count/2 {
-    let word = Input[i]
-    Dict[Box(word)] = Box(true)
-  }
-
+  dict = halfObjects
   // Count number of words from the first half in the entire text
   var count = 0
   for _ in 1...N {
-    for word in Input {
-      if Dict[Box(word)] != nil {
+    for word in text {
+      if dict[Box(word)] != nil {
         count += 1
       }
     }
diff --git a/benchmark/single-source/DropFirst.swift b/benchmark/single-source/DropFirst.swift
index 9e28c427cdace..bae534c7b7909 100644
--- a/benchmark/single-source/DropFirst.swift
+++ b/benchmark/single-source/DropFirst.swift
@@ -22,7 +22,7 @@ let sequenceCount = 4096
 let dropCount = 1024
 let suffixCount = sequenceCount - dropCount
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
-
+let array: [Int] = Array(0..<sequenceCount)
 
 public let DropFirst = [
   BenchmarkInfo(
@@ -52,7 +52,8 @@ public let DropFirst = [
   BenchmarkInfo(
     name: "DropFirstArray",
     runFunction: run_DropFirstArray,
-    tags: [.validation, .api, .Array]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
   BenchmarkInfo(
     name: "DropFirstCountableRangeLazy",
     runFunction: run_DropFirstCountableRangeLazy,
@@ -80,7 +81,8 @@ public let DropFirst = [
   BenchmarkInfo(
     name: "DropFirstArrayLazy",
     runFunction: run_DropFirstArrayLazy,
-    tags: [.validation, .api]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
 ]
 
 @inline(never)
@@ -151,7 +153,7 @@ public func run_DropFirstAnyCollection(_ N: Int) {
 }
 @inline(never)
 public func run_DropFirstArray(_ N: Int) {
-  let s = Array(0..<sequenceCount)
+  let s = array
   for _ in 1...20*N {
     var result = 0
     for element in s.dropFirst(dropCount) {
@@ -228,7 +230,7 @@ public func run_DropFirstAnyCollectionLazy(_ N: Int) {
 }
 @inline(never)
 public func run_DropFirstArrayLazy(_ N: Int) {
-  let s = (Array(0..<sequenceCount)).lazy
+  let s = (array).lazy
   for _ in 1...20*N {
     var result = 0
     for element in s.dropFirst(dropCount) {
diff --git a/benchmark/single-source/DropFirst.swift.gyb b/benchmark/single-source/DropFirst.swift.gyb
index c2e0e8d593056..7b52ee88b878f 100644
--- a/benchmark/single-source/DropFirst.swift.gyb
+++ b/benchmark/single-source/DropFirst.swift.gyb
@@ -23,6 +23,7 @@ let sequenceCount = 4096
 let dropCount = 1024
 let suffixCount = sequenceCount - dropCount
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 %{
 # Name and Expression pairs for Sequences to test.
 
@@ -35,20 +36,21 @@ Sequences = [
   ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
   ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
   ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
-  ('Array', 'Array(0..<sequenceCount)'),
+  ('Array', 'array'),
 ]
 def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
 
 Sequences = Sequences + map(lazy, Sequences)
 }%
 
-
 public let DropFirst = [
 % for (Name, Expr) in Sequences:
   BenchmarkInfo(
     name: "DropFirst${Name}",
     runFunction: run_DropFirst${Name},
-    tags: [.validation, .api${', .Array' if Name == 'Array' else ''}]),
+    tags: [.validation, .api${
+    ', .Array],\n    setUpFunction: { blackHole(array) })' if 'Array' in Name else
+    '])' },
 % end
 ]
 
diff --git a/benchmark/single-source/DropLast.swift b/benchmark/single-source/DropLast.swift
index fc47787237955..0df18f99b1fda 100644
--- a/benchmark/single-source/DropLast.swift
+++ b/benchmark/single-source/DropLast.swift
@@ -22,12 +22,13 @@ let sequenceCount = 4096
 let prefixCount = 1024
 let dropCount = sequenceCount - prefixCount
 let sumCount = prefixCount * (prefixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 
 public let DropLast = [
   BenchmarkInfo(
     name: "DropLastCountableRange",
     runFunction: run_DropLastCountableRange,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "DropLastSequence",
     runFunction: run_DropLastSequence,
@@ -51,11 +52,12 @@ public let DropLast = [
   BenchmarkInfo(
     name: "DropLastArray",
     runFunction: run_DropLastArray,
-    tags: [.validation, .api, .Array, .unstable]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
   BenchmarkInfo(
     name: "DropLastCountableRangeLazy",
     runFunction: run_DropLastCountableRangeLazy,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "DropLastSequenceLazy",
     runFunction: run_DropLastSequenceLazy,
@@ -79,7 +81,8 @@ public let DropLast = [
   BenchmarkInfo(
     name: "DropLastArrayLazy",
     runFunction: run_DropLastArrayLazy,
-    tags: [.validation, .api, .Array, .unstable]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
 ]
 
 @inline(never)
@@ -150,7 +153,7 @@ public func run_DropLastAnyCollection(_ N: Int) {
 }
 @inline(never)
 public func run_DropLastArray(_ N: Int) {
-  let s = Array(0..<sequenceCount)
+  let s = array
   for _ in 1...20*N {
     var result = 0
     for element in s.dropLast(dropCount) {
@@ -227,7 +230,7 @@ public func run_DropLastAnyCollectionLazy(_ N: Int) {
 }
 @inline(never)
 public func run_DropLastArrayLazy(_ N: Int) {
-  let s = (Array(0..<sequenceCount)).lazy
+  let s = (array).lazy
   for _ in 1...20*N {
     var result = 0
     for element in s.dropLast(dropCount) {
diff --git a/benchmark/single-source/DropLast.swift.gyb b/benchmark/single-source/DropLast.swift.gyb
index bcd93da4d432f..71a124ddf0dc4 100644
--- a/benchmark/single-source/DropLast.swift.gyb
+++ b/benchmark/single-source/DropLast.swift.gyb
@@ -23,6 +23,7 @@ let sequenceCount = 4096
 let prefixCount = 1024
 let dropCount = sequenceCount - prefixCount
 let sumCount = prefixCount * (prefixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 %{
 # Name and Expression pairs for Sequences to test.
 
@@ -35,7 +36,7 @@ Sequences = [
   ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
   ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
   ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
-  ('Array', 'Array(0..<sequenceCount)'),
+  ('Array', 'array'),
 ]
 def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
 
@@ -48,8 +49,8 @@ public let DropLast = [
     name: "DropLast${Name}",
     runFunction: run_DropLast${Name},
     tags: [.validation, .api${
-      ', .Array, .unstable' if Name == 'Array' or Name == 'ArrayLazy' else
-        ', .unstable' if 'CountableRange' in Name else ''}]),
+    ', .Array],\n    setUpFunction: { blackHole(array) })' if 'Array' in Name else
+    '])' },
 % end
 ]
 
diff --git a/benchmark/single-source/DropWhile.swift b/benchmark/single-source/DropWhile.swift
index 8a77c02ac7eb6..1649e1155ed58 100644
--- a/benchmark/single-source/DropWhile.swift
+++ b/benchmark/single-source/DropWhile.swift
@@ -22,6 +22,7 @@ let sequenceCount = 4096
 let dropCount = 1024
 let suffixCount = sequenceCount - dropCount
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 
 public let DropWhile = [
   BenchmarkInfo(
@@ -51,7 +52,8 @@ public let DropWhile = [
   BenchmarkInfo(
     name: "DropWhileArray",
     runFunction: run_DropWhileArray,
-    tags: [.validation, .api, .Array, .unstable]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
   BenchmarkInfo(
     name: "DropWhileCountableRangeLazy",
     runFunction: run_DropWhileCountableRangeLazy,
@@ -79,7 +81,8 @@ public let DropWhile = [
   BenchmarkInfo(
     name: "DropWhileArrayLazy",
     runFunction: run_DropWhileArrayLazy,
-    tags: [.validation, .api]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
 ]
 
 @inline(never)
@@ -150,7 +153,7 @@ public func run_DropWhileAnyCollection(_ N: Int) {
 }
 @inline(never)
 public func run_DropWhileArray(_ N: Int) {
-  let s = Array(0..<sequenceCount)
+  let s = array
   for _ in 1...20*N {
     var result = 0
     for element in s.drop(while: {$0 < dropCount} ) {
@@ -227,7 +230,7 @@ public func run_DropWhileAnyCollectionLazy(_ N: Int) {
 }
 @inline(never)
 public func run_DropWhileArrayLazy(_ N: Int) {
-  let s = (Array(0..<sequenceCount)).lazy
+  let s = (array).lazy
   for _ in 1...20*N {
     var result = 0
     for element in s.drop(while: {$0 < dropCount} ) {
diff --git a/benchmark/single-source/DropWhile.swift.gyb b/benchmark/single-source/DropWhile.swift.gyb
index 36020863778c1..2bdf6b6c3fe69 100644
--- a/benchmark/single-source/DropWhile.swift.gyb
+++ b/benchmark/single-source/DropWhile.swift.gyb
@@ -23,6 +23,7 @@ let sequenceCount = 4096
 let dropCount = 1024
 let suffixCount = sequenceCount - dropCount
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 %{
 # Name and Expression pairs for Sequences to test.
 
@@ -35,7 +36,7 @@ Sequences = [
   ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
   ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
   ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
-  ('Array', 'Array(0..<sequenceCount)'),
+  ('Array', 'array'),
 ]
 def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
 
@@ -47,7 +48,9 @@ public let DropWhile = [
   BenchmarkInfo(
     name: "DropWhile${Name}",
     runFunction: run_DropWhile${Name},
-    tags: [.validation, .api${', .Array, .unstable' if Name == 'Array' else ''}]),
+    tags: [.validation, .api${
+    ', .Array],\n    setUpFunction: { blackHole(array) })' if 'Array' in Name else
+    '])' },
 % end
 ]
 
diff --git a/benchmark/single-source/ExistentialPerformance.swift b/benchmark/single-source/ExistentialPerformance.swift
index a4632ea92bd92..7a39a6098fbd9 100644
--- a/benchmark/single-source/ExistentialPerformance.swift
+++ b/benchmark/single-source/ExistentialPerformance.swift
@@ -137,15 +137,16 @@ class ClassWithArrs {
     }
 
     func writeArr() {
-		for i in 0..<self.N {
-			A[i] = i
-			B[i] = i
-		}
+        for i in 0..<self.N {
+    			A[i] = i
+    			B[i] = i
+    		}
     }
 }
 
+let workload = ClassWithArrs(N: 100)
+
 public func run_DistinctClassFieldAccesses(_ N: Int) {
-    let workload = ClassWithArrs(N: 100)
     for _ in 1...N {
         workload.writeArr()
         workload.readArr()
diff --git a/benchmark/single-source/IterateData.swift b/benchmark/single-source/IterateData.swift
index 61958a1d49509..79c0596ec4e29 100644
--- a/benchmark/single-source/IterateData.swift
+++ b/benchmark/single-source/IterateData.swift
@@ -16,10 +16,10 @@ import Foundation
 public let IterateData = BenchmarkInfo(
   name: "IterateData",
   runFunction: run_IterateData,
-  tags: [.validation, .api, .Data])
+  tags: [.validation, .api, .Data],
+  setUpFunction: { blackHole(data) })
 
-@inline(never)
-func generateData() -> Data {
+let data: Data = {
   var data = Data(count: 16 * 1024)
   let n = data.count
   data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) -> () in
@@ -28,13 +28,11 @@ func generateData() -> Data {
     }
   }
   return data
-}
+}()
 
 @inline(never)
 public func run_IterateData(_ N: Int) {
-  let data = generateData()
-
-  for _ in 0...10*N {
+  for _ in 1...10*N {
     _ = data.reduce(0, &+)
   }
 }
diff --git a/benchmark/single-source/MapReduce.swift b/benchmark/single-source/MapReduce.swift
index c8525781f2b5d..d232fc0651d5a 100644
--- a/benchmark/single-source/MapReduce.swift
+++ b/benchmark/single-source/MapReduce.swift
@@ -17,8 +17,14 @@ public let MapReduce = [
   BenchmarkInfo(name: "MapReduce", runFunction: run_MapReduce, tags: [.validation, .algorithm]),
   BenchmarkInfo(name: "MapReduceAnyCollection", runFunction: run_MapReduceAnyCollection, tags: [.validation, .algorithm]),
   BenchmarkInfo(name: "MapReduceAnyCollectionShort", runFunction: run_MapReduceAnyCollectionShort, tags: [.validation, .algorithm]),
-  BenchmarkInfo(name: "MapReduceClass", runFunction: run_MapReduceClass, tags: [.validation, .algorithm]),
-  BenchmarkInfo(name: "MapReduceClassShort", runFunction: run_MapReduceClassShort, tags: [.validation, .algorithm]),
+  BenchmarkInfo(name: "MapReduceClass2", runFunction: run_MapReduceClass, tags: [.validation, .algorithm],
+    setUpFunction: { boxedNumbers(1000) }, tearDownFunction: releaseDecimals),
+  BenchmarkInfo(name: "MapReduceClassShort2", runFunction: run_MapReduceClassShort, tags: [.validation, .algorithm],
+    setUpFunction: { boxedNumbers(10) }, tearDownFunction: releaseDecimals),
+  BenchmarkInfo(name: "MapReduceNSDecimalNumber", runFunction: run_MapReduceNSDecimalNumber, tags: [.validation, .algorithm],
+    setUpFunction: { decimals(1000) }, tearDownFunction: releaseDecimals),
+  BenchmarkInfo(name: "MapReduceNSDecimalNumberShort", runFunction: run_MapReduceNSDecimalNumberShort, tags: [.validation, .algorithm],
+    setUpFunction: { decimals(10) }, tearDownFunction: releaseDecimals),
   BenchmarkInfo(name: "MapReduceLazyCollection", runFunction: run_MapReduceLazyCollection, tags: [.validation, .algorithm]),
   BenchmarkInfo(name: "MapReduceLazyCollectionShort", runFunction: run_MapReduceLazyCollectionShort, tags: [.validation, .algorithm]),
   BenchmarkInfo(name: "MapReduceLazySequence", runFunction: run_MapReduceLazySequence, tags: [.validation, .algorithm]),
@@ -28,6 +34,26 @@ public let MapReduce = [
   BenchmarkInfo(name: "MapReduceString", runFunction: run_MapReduceString, tags: [.validation, .algorithm, .String]),
 ]
 
+#if _runtime(_ObjC)
+var decimals : [NSDecimalNumber]!
+func decimals(_ n: Int) {
+  decimals = (0..<n).map { NSDecimalNumber(value: $0) }
+}
+func releaseDecimals() { decimals = nil }
+#else
+func decimals(_ n: Int) {}
+func releaseDecimals() {}
+#endif
+
+class Box {
+  var v: Int
+  init(_ v: Int) { self.v = v }
+}
+
+var boxedNumbers : [Box]!
+func boxedNumbers(_ n: Int) { boxedNumbers = (0..<n).map { Box($0) } }
+func releaseboxedNumbers() { boxedNumbers = nil }
+
 @inline(never)
 public func run_MapReduce(_ N: Int) {
   var numbers = [Int](0..<1000)
@@ -147,12 +173,12 @@ public func run_MapReduceShortString(_ N: Int) {
 }
 
 @inline(never)
-public func run_MapReduceClass(_ N: Int) {
+public func run_MapReduceNSDecimalNumber(_ N: Int) {
 #if _runtime(_ObjC)
-  let numbers = (0..<1000).map { NSDecimalNumber(value: $0) }
+  let numbers: [NSDecimalNumber] = decimals
 
   var c = 0
-  for _ in 1...N*100 {
+  for _ in 1...N*10 {
     let mapped = numbers.map { $0.intValue &+ 5 }
     c += mapped.reduce(0, &+)
   }
@@ -161,12 +187,12 @@ public func run_MapReduceClass(_ N: Int) {
 }
 
 @inline(never)
-public func run_MapReduceClassShort(_ N: Int) {
+public func run_MapReduceNSDecimalNumberShort(_ N: Int) {
 #if _runtime(_ObjC)
-  let numbers = (0..<10).map { NSDecimalNumber(value: $0) }
+  let numbers: [NSDecimalNumber] = decimals
 
   var c = 0
-  for _ in 1...N*10000 {
+  for _ in 1...N*1_000 {
     let mapped = numbers.map { $0.intValue &+ 5 }
     c += mapped.reduce(0, &+)
   }
@@ -174,3 +200,27 @@ public func run_MapReduceClassShort(_ N: Int) {
 #endif
 }
 
+
+@inline(never)
+public func run_MapReduceClass(_ N: Int) {
+  let numbers: [Box] = boxedNumbers
+
+  var c = 0
+  for _ in 1...N*10 {
+    let mapped = numbers.map { $0.v &+ 5 }
+    c += mapped.reduce(0, &+)
+  }
+  CheckResults(c != 0)
+}
+
+@inline(never)
+public func run_MapReduceClassShort(_ N: Int) {
+  let numbers: [Box] = boxedNumbers
+
+  var c = 0
+  for _ in 1...N*1_000 {
+    let mapped = numbers.map { $0.v &+ 5 }
+    c += mapped.reduce(0, &+)
+  }
+  CheckResults(c != 0)
+}
diff --git a/benchmark/single-source/Phonebook.swift b/benchmark/single-source/Phonebook.swift
index 043cd535995a3..5c76ba9bacb16 100644
--- a/benchmark/single-source/Phonebook.swift
+++ b/benchmark/single-source/Phonebook.swift
@@ -17,9 +17,11 @@ import TestsUtils
 public let Phonebook = BenchmarkInfo(
   name: "Phonebook",
   runFunction: run_Phonebook,
-  tags: [.validation, .api, .String])
+  tags: [.validation, .api, .String],
+  setUpFunction: { blackHole(names) }
+)
 
-var words = [
+let words = [
   "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph",
   "Charles", "Thomas", "Christopher", "Daniel", "Matthew", "Donald", "Anthony",
   "Paul", "Mark", "George", "Steven", "Kenneth", "Andrew", "Edward", "Brian",
@@ -34,6 +36,17 @@ var words = [
   "Jordan", "Russell", "Alan", "Philip", "Randy", "Juan", "Howard", "Vincent",
   "Bobby", "Dylan", "Johnny", "Phillip", "Craig"
 ]
+let names: [Record] = {
+  // The list of names in the phonebook.
+  var names = [Record]()
+  names.reserveCapacity(words.count * words.count)
+  for first in words {
+    for last in words {
+      names.append(Record(first, last))
+    }
+  }
+  return names
+}()
 
 // This is a phone book record.
 struct Record : Comparable {
@@ -66,15 +79,8 @@ func <(lhs: Record, rhs: Record) -> Bool {
 
 @inline(never)
 public func run_Phonebook(_ N: Int) {
-  // The list of names in the phonebook.
-  var Names : [Record] = []
-  for first in words {
-    for last in words {
-      Names.append(Record(first, last))
-    }
-  }
   for _ in 1...N {
-    var t = Names
+    var t = names
     t.sort()
   }
 }
diff --git a/benchmark/single-source/PolymorphicCalls.swift b/benchmark/single-source/PolymorphicCalls.swift
index 64aedae9fd399..cb688ce0f1920 100644
--- a/benchmark/single-source/PolymorphicCalls.swift
+++ b/benchmark/single-source/PolymorphicCalls.swift
@@ -308,32 +308,22 @@ func test(_ a3_c3: A3, _ a3_d3: A3, _ a3_e3: A3, _ a3_f3: A3, _ UPTO: Int) -> In
     return cnt
 }
 
-
+let a = A(b:B(x:1))
+let a1 = A1(b:C1(x:1))
+let a2 = A2(b:C2(x:1))
+let a2_c2 = A2(b:C2(x:1))
+let a2_d2 = A2(b:D2(x:1))
+let a3_c3 = A3(b:C3(x:1))
+let a3_d3 = A3(b:D3(x:1))
+let a3_e3 = A3(b:E3(x:1))
+let a3_f3 = A3(b:F3(x:1))
 
 @inline(never)
 public func run_PolymorphicCalls(_ N:Int) {
-    let UPTO = 10000 * N
-
-    let a = A(b:B(x:1))
+    let UPTO = 10_000 * N
     _ = test(a, UPTO)
-
-    let a1 = A1(b:C1(x:1))
-
     _ = test(a1, UPTO)
-
-    let a2 = A2(b:C2(x:1))
-
     _ = test(a2, UPTO)
-
-    let a2_c2 = A2(b:C2(x:1))
-    let a2_d2 = A2(b:D2(x:1))
-
     _ = test(a2_c2, a2_d2, UPTO)
-
-    let a3_c3 = A3(b:C3(x:1))
-    let a3_d3 = A3(b:D3(x:1))
-    let a3_e3 = A3(b:E3(x:1))
-    let a3_f3 = A3(b:F3(x:1))
-
     _ = test(a3_c3, a3_d3, a3_e3, a3_f3, UPTO)
 }
diff --git a/benchmark/single-source/Prefix.swift b/benchmark/single-source/Prefix.swift
index 00e6b800d7b33..b442e710a693a 100644
--- a/benchmark/single-source/Prefix.swift
+++ b/benchmark/single-source/Prefix.swift
@@ -21,6 +21,7 @@ import TestsUtils
 let sequenceCount = 4096
 let prefixCount = sequenceCount - 1024
 let sumCount = prefixCount * (prefixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 
 public let Prefix = [
   BenchmarkInfo(
@@ -50,7 +51,8 @@ public let Prefix = [
   BenchmarkInfo(
     name: "PrefixArray",
     runFunction: run_PrefixArray,
-    tags: [.validation, .api, .Array]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
   BenchmarkInfo(
     name: "PrefixCountableRangeLazy",
     runFunction: run_PrefixCountableRangeLazy,
@@ -78,7 +80,8 @@ public let Prefix = [
   BenchmarkInfo(
     name: "PrefixArrayLazy",
     runFunction: run_PrefixArrayLazy,
-    tags: [.validation, .api]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
 ]
 
 @inline(never)
@@ -149,7 +152,7 @@ public func run_PrefixAnyCollection(_ N: Int) {
 }
 @inline(never)
 public func run_PrefixArray(_ N: Int) {
-  let s = Array(0..<sequenceCount)
+  let s = array
   for _ in 1...20*N {
     var result = 0
     for element in s.prefix(prefixCount) {
@@ -226,7 +229,7 @@ public func run_PrefixAnyCollectionLazy(_ N: Int) {
 }
 @inline(never)
 public func run_PrefixArrayLazy(_ N: Int) {
-  let s = (Array(0..<sequenceCount)).lazy
+  let s = (array).lazy
   for _ in 1...20*N {
     var result = 0
     for element in s.prefix(prefixCount) {
diff --git a/benchmark/single-source/Prefix.swift.gyb b/benchmark/single-source/Prefix.swift.gyb
index 2ca51353f6a56..c4fe33478a75f 100644
--- a/benchmark/single-source/Prefix.swift.gyb
+++ b/benchmark/single-source/Prefix.swift.gyb
@@ -22,6 +22,7 @@ import TestsUtils
 let sequenceCount = 4096
 let prefixCount = sequenceCount - 1024
 let sumCount = prefixCount * (prefixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 %{
 # Name and initializer Expression pairs for Sequences to test.
 
@@ -34,7 +35,7 @@ Sequences = [
   ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
   ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
   ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
-  ('Array', 'Array(0..<sequenceCount)'),
+  ('Array', 'array'),
 ]
 def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
 
@@ -46,7 +47,9 @@ public let Prefix = [
   BenchmarkInfo(
     name: "Prefix${Name}",
     runFunction: run_Prefix${Name},
-    tags: [.validation, .api${', .Array' if Name == 'Array' else ''}]),
+    tags: [.validation, .api${
+    ', .Array],\n    setUpFunction: { blackHole(array) })' if 'Array' in Name else
+    '])' },
 % end
 ]
 
diff --git a/benchmark/single-source/PrefixWhile.swift b/benchmark/single-source/PrefixWhile.swift
index 1038a741fddc5..c2379bf96310b 100644
--- a/benchmark/single-source/PrefixWhile.swift
+++ b/benchmark/single-source/PrefixWhile.swift
@@ -21,12 +21,13 @@ import TestsUtils
 let sequenceCount = 4096
 let prefixCount = sequenceCount - 1024
 let sumCount = prefixCount * (prefixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 
 public let PrefixWhile = [
   BenchmarkInfo(
     name: "PrefixWhileCountableRange",
     runFunction: run_PrefixWhileCountableRange,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "PrefixWhileSequence",
     runFunction: run_PrefixWhileSequence,
@@ -38,7 +39,7 @@ public let PrefixWhile = [
   BenchmarkInfo(
     name: "PrefixWhileAnySeqCntRange",
     runFunction: run_PrefixWhileAnySeqCntRange,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "PrefixWhileAnySeqCRangeIter",
     runFunction: run_PrefixWhileAnySeqCRangeIter,
@@ -50,11 +51,12 @@ public let PrefixWhile = [
   BenchmarkInfo(
     name: "PrefixWhileArray",
     runFunction: run_PrefixWhileArray,
-    tags: [.validation, .api, .Array]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
   BenchmarkInfo(
     name: "PrefixWhileCountableRangeLazy",
     runFunction: run_PrefixWhileCountableRangeLazy,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "PrefixWhileSequenceLazy",
     runFunction: run_PrefixWhileSequenceLazy,
@@ -66,7 +68,7 @@ public let PrefixWhile = [
   BenchmarkInfo(
     name: "PrefixWhileAnySeqCntRangeLazy",
     runFunction: run_PrefixWhileAnySeqCntRangeLazy,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "PrefixWhileAnySeqCRangeIterLazy",
     runFunction: run_PrefixWhileAnySeqCRangeIterLazy,
@@ -78,7 +80,8 @@ public let PrefixWhile = [
   BenchmarkInfo(
     name: "PrefixWhileArrayLazy",
     runFunction: run_PrefixWhileArrayLazy,
-    tags: [.validation, .api]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
 ]
 
 @inline(never)
@@ -149,7 +152,7 @@ public func run_PrefixWhileAnyCollection(_ N: Int) {
 }
 @inline(never)
 public func run_PrefixWhileArray(_ N: Int) {
-  let s = Array(0..<sequenceCount)
+  let s = array
   for _ in 1...20*N {
     var result = 0
     for element in s.prefix(while: {$0 < prefixCount} ) {
@@ -226,7 +229,7 @@ public func run_PrefixWhileAnyCollectionLazy(_ N: Int) {
 }
 @inline(never)
 public func run_PrefixWhileArrayLazy(_ N: Int) {
-  let s = (Array(0..<sequenceCount)).lazy
+  let s = (array).lazy
   for _ in 1...20*N {
     var result = 0
     for element in s.prefix(while: {$0 < prefixCount} ) {
diff --git a/benchmark/single-source/PrefixWhile.swift.gyb b/benchmark/single-source/PrefixWhile.swift.gyb
index 8820515a12e42..4b5db14d4385d 100644
--- a/benchmark/single-source/PrefixWhile.swift.gyb
+++ b/benchmark/single-source/PrefixWhile.swift.gyb
@@ -22,6 +22,7 @@ import TestsUtils
 let sequenceCount = 4096
 let prefixCount = sequenceCount - 1024
 let sumCount = prefixCount * (prefixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 %{
 # Name and initializer Expression pairs for Sequences to test.
 
@@ -34,7 +35,7 @@ Sequences = [
   ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
   ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
   ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
-  ('Array', 'Array(0..<sequenceCount)'),
+  ('Array', 'array'),
 ]
 def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
 
@@ -47,8 +48,8 @@ public let PrefixWhile = [
     name: "PrefixWhile${Name}",
     runFunction: run_PrefixWhile${Name},
     tags: [.validation, .api${
-      ', .Array' if Name == 'Array' else
-        ', .unstable' if 'CountableRange' in Name or 'AnySeqCntRange' in Name else ''}]),
+    ', .Array],\n    setUpFunction: { blackHole(array) })' if 'Array' in Name else
+    '])' },
 % end
 ]
 
diff --git a/benchmark/single-source/RandomShuffle.swift b/benchmark/single-source/RandomShuffle.swift
index de319dd88733d..9d26ee6f77cc2 100644
--- a/benchmark/single-source/RandomShuffle.swift
+++ b/benchmark/single-source/RandomShuffle.swift
@@ -20,47 +20,43 @@ import TestsUtils
 public let RandomShuffle = [
   BenchmarkInfo(name: "RandomShuffleDef2", runFunction: run_RandomShuffleDef,
     tags: [.api],
-    setUpFunction: { blackHole(numbersDef) },
-    tearDownFunction: { numbersDef = nil }),
+    setUpFunction: { blackHole(numbersDef) }),
   BenchmarkInfo(name: "RandomShuffleLCG2", runFunction: run_RandomShuffleLCG,
     tags: [.api],
-    setUpFunction: { blackHole(numbersLCG) },
-    tearDownFunction: { numbersLCG = nil }),
+    setUpFunction: { blackHole(numbersLCG) }),
 ]
 
 /// A linear congruential PRNG.
 struct LCRNG: RandomNumberGenerator {
   private var state: UInt64
-  
+
   init(seed: Int) {
     state = UInt64(truncatingIfNeeded: seed)
     for _ in 0..<10 { _ = next() }
   }
-  
+
   mutating func next() -> UInt64 {
     state = 2862933555777941757 &* state &+ 3037000493
     return state
   }
 }
 
-var numbersDef: [Int]! = Array(0...10_000)
-var numbersLCG: [Int]! = Array(0...100_000)
+var numbersDef: [Int] = Array(0...10_000)
+var numbersLCG: [Int] = Array(0...100_000)
 
 @inline(never)
 public func run_RandomShuffleDef(_ N: Int) {
-  var numbers: [Int] = numbersDef
   for _ in 0 ..< N {
-    numbers.shuffle()
-    blackHole(numbers.first!)
+    numbersDef.shuffle()
+    blackHole(numbersDef.first!)
   }
 }
 
 @inline(never)
 public func run_RandomShuffleLCG(_ N: Int) {
-  var numbers: [Int] = numbersLCG
   var generator = LCRNG(seed: 0)
   for _ in 0 ..< N {
-    numbers.shuffle(using: &generator)
-    blackHole(numbers.first!)
+    numbersLCG.shuffle(using: &generator)
+    blackHole(numbersLCG.first!)
   }
 }
diff --git a/benchmark/single-source/SortStrings.swift b/benchmark/single-source/SortStrings.swift
index 6c0796054d6cb..3baaed2ab00d3 100644
--- a/benchmark/single-source/SortStrings.swift
+++ b/benchmark/single-source/SortStrings.swift
@@ -13,12 +13,16 @@ import TestsUtils
 
 // Sort an array of strings using an explicit sort predicate.
 public let SortStrings = [
-  BenchmarkInfo(name: "SortSortedStrings", runFunction: run_SortSortedStrings, tags: [.validation, .api, .algorithm, .String]),
-  BenchmarkInfo(name: "SortStrings", runFunction: run_SortStrings, tags: [.validation, .api, .algorithm, .String]),
-  BenchmarkInfo(name: "SortStringsUnicode", runFunction: run_SortStringsUnicode, tags: [.validation, .api, .algorithm, .String]),
+  BenchmarkInfo(name: "SortSortedStrings", runFunction: run_SortSortedStrings, tags: [.validation, .api, .algorithm, .String],
+    setUpFunction: { blackHole(sortedWords) }),
+  BenchmarkInfo(name: "SortStrings", runFunction: run_SortStrings, tags: [.validation, .api, .algorithm, .String],
+    setUpFunction: { blackHole(words) }),
+  BenchmarkInfo(name: "SortStringsUnicode", runFunction: run_SortStringsUnicode, tags: [.validation, .api, .algorithm, .String],
+    setUpFunction: { blackHole(unicodeWords) }),
 ]
 
-var stringBenchmarkWords: [String] = [
+let sortedWords = words.sorted()
+let words: [String] = [
   "woodshed",
   "lakism",
   "gastroperiodynia",
@@ -1032,18 +1036,17 @@ func benchSortStrings(_ words: [String]) {
 
 public func run_SortStrings(_ N: Int) {
   for _ in 1...5*N {
-    benchSortStrings(stringBenchmarkWords)
+    benchSortStrings(words)
   }
 }
 
 public func run_SortSortedStrings(_ N: Int) {
-  let sortedBenchmarkWords = stringBenchmarkWords.sorted()
   for _ in 1...5*N {
-    benchSortStrings(sortedBenchmarkWords)
+    benchSortStrings(sortedWords)
   }
 }
 
-var stringBenchmarkWordsUnicode: [String] = [
+var unicodeWords: [String] = [
   "❄️woodshed",
   "❄️lakism",
   "❄️gastroperiodynia",
@@ -2048,6 +2051,6 @@ var stringBenchmarkWordsUnicode: [String] = [
 
 public func run_SortStringsUnicode(_ N: Int) {
   for _ in 1...5*N {
-    benchSortStrings(stringBenchmarkWordsUnicode)
+    benchSortStrings(unicodeWords)
   }
 }
diff --git a/benchmark/single-source/Substring.swift b/benchmark/single-source/Substring.swift
index c529d086c5bfc..bd3aab887be8c 100644
--- a/benchmark/single-source/Substring.swift
+++ b/benchmark/single-source/Substring.swift
@@ -21,7 +21,8 @@ public let SubstringTest = [
   BenchmarkInfo(name: "LessSubstringSubstringGenericComparable", runFunction: run_LessSubstringSubstringGenericComparable, tags: [.validation, .api, .String]),
   BenchmarkInfo(name: "StringFromLongWholeSubstring", runFunction: run_StringFromLongWholeSubstring, tags: [.validation, .api, .String]),
   BenchmarkInfo(name: "StringFromLongWholeSubstringGeneric", runFunction: run_StringFromLongWholeSubstringGeneric, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "SubstringComparable", runFunction: run_SubstringComparable, tags: [.validation, .api, .String]),
+  BenchmarkInfo(name: "SubstringComparable", runFunction: run_SubstringComparable, tags: [.validation, .api, .String],
+    setUpFunction: { blackHole(_comparison) }),
   BenchmarkInfo(name: "SubstringEqualString", runFunction: run_SubstringEqualString, tags: [.validation, .api, .String]),
   BenchmarkInfo(name: "SubstringEquatable", runFunction: run_SubstringEquatable, tags: [.validation, .api, .String]),
   BenchmarkInfo(name: "SubstringFromLongString", runFunction: run_SubstringFromLongString, tags: [.validation, .api, .String]),
@@ -79,7 +80,7 @@ private func equivalentWithDistinctBuffers() -> (String, Substring) {
   var s0 = longWide
   withUnsafeMutablePointer(to: &s0) { blackHole($0) }
   s0 += "!"
-  
+
   // These two should be equal but with distinct buffers, both refcounted.
   let a = Substring(s0).dropFirst()
   let b = String(a)
@@ -226,12 +227,13 @@ public func run_SubstringEqualString(_ N: Int) {
   CheckResults(count == 2*N*500)
 }
 
+let _substrings = "pen,pineapple,apple,pen,✒️,🍍,🍏,✒️".split(separator: ",")
+let _comparison = _substrings + ["PPAP"]
+
 @inline(never)
 public func run_SubstringComparable(_ N: Int) {
-	var string = "pen,pineapple,apple,pen"
-	string += ",✒️,🍍,🍏,✒️"
-	let substrings = string.split(separator: ",")
-	let comparison = substrings + ["PPAP"]
+	let substrings = _substrings // without this alias, there was 25% slowdown
+	let comparison = _comparison // due to increased retain/release traffic 🤷‍‍
 	var count = 0
 	for _ in 1...N*500 {
 		if substrings.lexicographicallyPrecedes(comparison) {
diff --git a/benchmark/single-source/Suffix.swift b/benchmark/single-source/Suffix.swift
index ace24f65a1cba..ae44759057fb9 100644
--- a/benchmark/single-source/Suffix.swift
+++ b/benchmark/single-source/Suffix.swift
@@ -21,12 +21,13 @@ import TestsUtils
 let sequenceCount = 4096
 let suffixCount = 1024
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 
 public let Suffix = [
   BenchmarkInfo(
     name: "SuffixCountableRange",
     runFunction: run_SuffixCountableRange,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "SuffixSequence",
     runFunction: run_SuffixSequence,
@@ -50,11 +51,12 @@ public let Suffix = [
   BenchmarkInfo(
     name: "SuffixArray",
     runFunction: run_SuffixArray,
-    tags: [.validation, .api, .Array, .unstable]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
   BenchmarkInfo(
     name: "SuffixCountableRangeLazy",
     runFunction: run_SuffixCountableRangeLazy,
-    tags: [.validation, .api, .unstable]),
+    tags: [.validation, .api]),
   BenchmarkInfo(
     name: "SuffixSequenceLazy",
     runFunction: run_SuffixSequenceLazy,
@@ -78,7 +80,8 @@ public let Suffix = [
   BenchmarkInfo(
     name: "SuffixArrayLazy",
     runFunction: run_SuffixArrayLazy,
-    tags: [.validation, .api, .Array, .unstable]),
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(array) }),
 ]
 
 @inline(never)
@@ -149,7 +152,7 @@ public func run_SuffixAnyCollection(_ N: Int) {
 }
 @inline(never)
 public func run_SuffixArray(_ N: Int) {
-  let s = Array(0..<sequenceCount)
+  let s = array
   for _ in 1...20*N {
     var result = 0
     for element in s.suffix(suffixCount) {
@@ -226,7 +229,7 @@ public func run_SuffixAnyCollectionLazy(_ N: Int) {
 }
 @inline(never)
 public func run_SuffixArrayLazy(_ N: Int) {
-  let s = (Array(0..<sequenceCount)).lazy
+  let s = (array).lazy
   for _ in 1...20*N {
     var result = 0
     for element in s.suffix(suffixCount) {
diff --git a/benchmark/single-source/Suffix.swift.gyb b/benchmark/single-source/Suffix.swift.gyb
index 8a949d60a5dbb..1fa1a2626334a 100644
--- a/benchmark/single-source/Suffix.swift.gyb
+++ b/benchmark/single-source/Suffix.swift.gyb
@@ -22,6 +22,7 @@ import TestsUtils
 let sequenceCount = 4096
 let suffixCount = 1024
 let sumCount = suffixCount * (2 * sequenceCount - suffixCount - 1) / 2
+let array: [Int] = Array(0..<sequenceCount)
 %{
 # Name and initializer Expression pairs for Sequences to test.
 
@@ -34,7 +35,7 @@ Sequences = [
   ('AnySeqCntRange', 'AnySequence(0..<sequenceCount)'),
   ('AnySeqCRangeIter', 'AnySequence((0..<sequenceCount).makeIterator())'),
   ('AnyCollection', 'AnyCollection(0..<sequenceCount)'),
-  ('Array', 'Array(0..<sequenceCount)'),
+  ('Array', 'array'),
 ]
 def lazy ((Name, Expr)) : return (Name + 'Lazy', '(' + Expr + ').lazy')
 
@@ -47,8 +48,8 @@ public let Suffix = [
     name: "Suffix${Name}",
     runFunction: run_Suffix${Name},
     tags: [.validation, .api${
-      ', .Array, .unstable' if Name == 'Array' or Name == 'ArrayLazy' else
-        ', .unstable' if 'CountableRange' in Name else ''}]),
+    ', .Array],\n    setUpFunction: { blackHole(array) })' if 'Array' in Name else
+    '])' },
 % end
 ]