diff --git a/benchmark/single-source/SetTests.swift b/benchmark/single-source/SetTests.swift
index d6f815d175821..07b4e7b7f9d09 100644
--- a/benchmark/single-source/SetTests.swift
+++ b/benchmark/single-source/SetTests.swift
@@ -12,107 +12,288 @@
 
 import TestsUtils
 
+let size = 400
+let half = size / 2
+let quarter = size / 4
+
+// Construction kit for sets with 25% overlap
+let setAB = Set(0 ..< size)                              //   0 ..< 400
+let setCD = Set(size ..< 2 * size)                       // 400 ..< 800
+let setBC = Set(size - quarter ..< 2 * size - quarter)   // 300 ..< 700
+let setB = Set(size - quarter ..< size)                  // 300 ..< 400
+
+let setOAB = Set(setAB.map(Box.init))
+let setOCD = Set(setCD.map(Box.init))
+let setOBC = Set(setBC.map(Box.init))
+let setOB = Set(setB.map(Box.init))
+
+let countA = size - quarter        // 300
+let countB = quarter               // 100
+let countC = countA                // 300
+let countD = countB                // 100
+
+let countAB = size                 // 400
+let countAC = countA + countC      // 600
+let countABC = countA + countB + countC           // 700
+let countABCD = countA + countB + countC + countD // 800
+
+// Construction kit for sets with 50% overlap
+let setXY = Set(0 ..< size)           //   0 ..< 400
+let setYZ = Set(half ..< size + half) // 200 ..< 600
+let setY = Set(half ..< size)         // 200 ..< 400
+
+// Two sets with 100% overlap, but different bucket counts (let's not make it
+// too easy...)
+let setP = Set(0 ..< size)
+let setQ: Set<Int> = {
+  var set = Set(0 ..< size)
+  set.reserveCapacity(2 * size)
+  return set
+}()
+
 public let SetTests = [
-  BenchmarkInfo(name: "SetExclusiveOr", runFunction: run_SetExclusiveOr, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetExclusiveOr_OfObjects", runFunction: run_SetExclusiveOr_OfObjects, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetIntersect", runFunction: run_SetIntersect, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetIntersect_OfObjects", runFunction: run_SetIntersect_OfObjects, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetIsSubsetOf", runFunction: run_SetIsSubsetOf, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetIsSubsetOf_OfObjects", runFunction: run_SetIsSubsetOf_OfObjects, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetUnion", runFunction: run_SetUnion, tags: [.validation, .api, .Set]),
-  BenchmarkInfo(name: "SetUnion_OfObjects", runFunction: run_SetUnion_OfObjects, tags: [.validation, .api, .Set]),
+  // Mnemonic: number after name is percentage of common elements in input sets.
+  BenchmarkInfo(
+    name: "SetIsSubsetInt0",
+    runFunction: { n in run_SetIsSubsetInt(setAB, setCD, false, 5000 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetIsSubsetBox0",
+    runFunction: { n in run_SetIsSubsetBox(setOAB, setOCD, false, 5000 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "SetIsSubsetInt25",
+    runFunction: { n in run_SetIsSubsetInt(setB, setAB, true, 50 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setB, setAB]) }),
+  BenchmarkInfo(
+    name: "SetIsSubsetBox25",
+    runFunction: { n in run_SetIsSubsetBox(setOB, setOAB, true, 50 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOB, setOAB]) }),
+  BenchmarkInfo(
+    name: "SetIsSubsetInt50",
+    runFunction: { n in run_SetIsSubsetInt(setY, setXY, true, 50 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setY, setXY]) }),
+  BenchmarkInfo(
+    name: "SetIsSubsetInt100",
+    runFunction: { n in run_SetIsSubsetInt(setP, setQ, true, 50 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setP, setQ]) }),
+
+  BenchmarkInfo(
+    name: "SetSymmetricDifferenceInt0",
+    runFunction: { n in run_SetSymmetricDifferenceInt(setAB, setCD, countABCD, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetSymmetricDifferenceBox0",
+    runFunction: { n in run_SetSymmetricDifferenceBox(setOAB, setOCD, countABCD, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "SetSymmetricDifferenceInt25",
+    runFunction: { n in run_SetSymmetricDifferenceInt(setAB, setBC, countAC, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setBC]) }),
+  BenchmarkInfo(
+    name: "SetSymmetricDifferenceBox25",
+    runFunction: { n in run_SetSymmetricDifferenceBox(setOAB, setOBC, countAC, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOBC]) }),
+  BenchmarkInfo(
+    name: "SetSymmetricDifferenceInt50",
+    runFunction: { n in run_SetSymmetricDifferenceInt(setXY, setYZ, size, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setXY, setYZ]) }),
+  BenchmarkInfo(
+    name: "SetSymmetricDifferenceInt100",
+    runFunction: { n in run_SetSymmetricDifferenceInt(setP, setQ, 0, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setP, setQ]) }),
+
+  BenchmarkInfo(
+    name: "SetIntersectionInt0",
+    runFunction: { n in run_SetIntersectionInt(setAB, setCD, 0, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetIntersectionBox0",
+    runFunction: { n in run_SetIntersectionBox(setOAB, setOCD, 0, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "SetIntersectionInt25",
+    runFunction: { n in run_SetIntersectionInt(setAB, setBC, countB, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setBC]) }),
+  BenchmarkInfo(
+    name: "SetIntersectionBox25",
+    runFunction: { n in run_SetIntersectionBox(setOAB, setOBC, countB, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOBC]) }),
+  BenchmarkInfo(
+    name: "SetIntersectionInt50",
+    runFunction: { n in run_SetIntersectionInt(setXY, setYZ, half, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setXY, setYZ]) }),
+  BenchmarkInfo(
+    name: "SetIntersectionInt100",
+    runFunction: { n in run_SetIntersectionInt(setP, setQ, size, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setP, setQ]) }),
+
+  BenchmarkInfo(
+    name: "SetUnionInt0",
+    runFunction: { n in run_SetUnionInt(setAB, setCD, countABCD, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetUnionBox0",
+    runFunction: { n in run_SetUnionBox(setOAB, setOCD, countABCD, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "SetUnionInt25",
+    runFunction: { n in run_SetUnionInt(setAB, setBC, countABC, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setBC]) }),
+  BenchmarkInfo(
+    name: "SetUnionBox25",
+    runFunction: { n in run_SetUnionBox(setOAB, setOBC, countABC, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOBC]) }),
+  BenchmarkInfo(
+    name: "SetUnionInt50",
+    runFunction: { n in run_SetUnionInt(setXY, setYZ, size + half, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setXY, setYZ]) }),
+  BenchmarkInfo(
+    name: "SetUnionInt100",
+    runFunction: { n in run_SetUnionInt(setP, setQ, size, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setP, setQ]) }),
+
+  BenchmarkInfo(
+    name: "SetSubtractingInt0",
+    runFunction: { n in run_SetSubtractingInt(setAB, setCD, countAB, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetSubtractingBox0",
+    runFunction: { n in run_SetSubtractingBox(setOAB, setOCD, countAB, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "SetSubtractingInt25",
+    runFunction: { n in run_SetSubtractingInt(setAB, setBC, countA, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setBC]) }),
+  BenchmarkInfo(
+    name: "SetSubtractingBox25",
+    runFunction: { n in run_SetSubtractingBox(setOAB, setOBC, countA, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOBC]) }),
+  BenchmarkInfo(
+    name: "SetSubtractingInt50",
+    runFunction: { n in run_SetSubtractingInt(setXY, setYZ, half, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setXY, setYZ]) }),
+  BenchmarkInfo(
+    name: "SetSubtractingInt100",
+    runFunction: { n in run_SetSubtractingInt(setP, setQ, 0, 10 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setP, setQ]) }),
+
+  // Legacy benchmarks, kept for continuity with previous releases.
+  BenchmarkInfo(
+    name: "SetExclusiveOr", // ~"SetSymmetricDifferenceInt0"
+    runFunction: { n in run_SetSymmetricDifferenceInt(setAB, setCD, countABCD, 100 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetExclusiveOr_OfObjects", // ~"SetSymmetricDifferenceBox0"
+    runFunction: { n in run_SetSymmetricDifferenceBox(setOAB, setOCD, countABCD, 100 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "SetIntersect", // ~"SetIntersectionInt0"
+    runFunction: { n in run_SetIntersectionInt(setAB, setCD, 0, 100 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetUnion", // ~"SetUnionInt0"
+    runFunction: { n in run_SetUnionInt(setAB, setCD, countABCD, 100 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCD]) }),
+  BenchmarkInfo(
+    name: "SetUnion_OfObjects", // ~"SetUnionBox0"
+    runFunction: { n in run_SetUnionBox(setOAB, setOCD, countABCD, 100 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCD]) }),
 ]
 
 @inline(never)
-public func run_SetIsSubsetOf(_ N: Int) {
-  let size = 200
-
-  SRand()
-
-  var set = Set<Int>(minimumCapacity: size)
-  var otherSet = Set<Int>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Int(truncatingIfNeeded: Random()))
-    otherSet.insert(Int(truncatingIfNeeded: Random()))
-  }
-
-  var isSubset = false
-  for _ in 0 ..< N * 5000 {
-    isSubset = set.isSubset(of: otherSet)
-    if isSubset {
-      break
-    }
+public func run_SetIsSubsetInt(
+  _ a: Set<Int>,
+  _ b: Set<Int>,
+  _ r: Bool,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let isSubset = a.isSubset(of: identity(b))
+    CheckResults(isSubset == r)
   }
-
-  CheckResults(!isSubset)
 }
 
 @inline(never)
-func sink(_ s: inout Set<Int>) {
+public func run_SetSymmetricDifferenceInt(
+  _ a: Set<Int>,
+  _ b: Set<Int>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let diff = a.symmetricDifference(identity(b))
+    CheckResults(diff.count == r)
+  }
 }
 
 @inline(never)
-public func run_SetExclusiveOr(_ N: Int) {
-  let size = 400
-
-  SRand()
-
-  var set = Set<Int>(minimumCapacity: size)
-  var otherSet = Set<Int>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Int(truncatingIfNeeded: Random()))
-    otherSet.insert(Int(truncatingIfNeeded: Random()))
+public func run_SetUnionInt(
+  _ a: Set<Int>,
+  _ b: Set<Int>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let or = a.union(identity(b))
+    CheckResults(or.count == r)
   }
-
-  var xor = Set<Int>()
-  for _ in 0 ..< N * 100 {
-    xor = set.symmetricDifference(otherSet)
-  }
-  sink(&xor)
 }
 
 @inline(never)
-public func run_SetUnion(_ N: Int) {
-  let size = 400
-
-  SRand()
-
-  var set = Set<Int>(minimumCapacity: size)
-  var otherSet = Set<Int>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Int(truncatingIfNeeded: Random()))
-    otherSet.insert(Int(truncatingIfNeeded: Random()))
-  }
-
-  var or = Set<Int>()
-  for _ in 0 ..< N * 100 {
-    or = set.union(otherSet)
+public func run_SetIntersectionInt(
+  _ a: Set<Int>,
+  _ b: Set<Int>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let and = a.intersection(identity(b))
+    CheckResults(and.count == r)
   }
-  sink(&or)
 }
 
 @inline(never)
-public func run_SetIntersect(_ N: Int) {
-  let size = 400
-
-  SRand()
-
-  var set = Set<Int>(minimumCapacity: size)
-  var otherSet = Set<Int>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Int(truncatingIfNeeded: Random()))
-    otherSet.insert(Int(truncatingIfNeeded: Random()))
-  }
-
-  var and = Set<Int>()
-  for _ in 0 ..< N * 100 {
-    and = set.intersection(otherSet)
+public func run_SetSubtractingInt(
+  _ a: Set<Int>,
+  _ b: Set<Int>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let and = a.subtracting(identity(b))
+    CheckResults(and.count == r)
   }
-  sink(&and)
 }
 
 class Box<T : Hashable> : Hashable {
@@ -132,93 +313,61 @@ class Box<T : Hashable> : Hashable {
 }
 
 @inline(never)
-public func run_SetIsSubsetOf_OfObjects(_ N: Int) {
-  let size = 200
-
-  SRand()
-
-  var set = Set<Box<Int>>(minimumCapacity: size)
-  var otherSet = Set<Box<Int>>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Box(Int(truncatingIfNeeded: Random())))
-    otherSet.insert(Box(Int(truncatingIfNeeded: Random())))
+func run_SetIsSubsetBox(
+  _ a: Set<Box<Int>>,
+  _ b: Set<Box<Int>>,
+  _ r: Bool,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let isSubset = a.isSubset(of: identity(b))
+    CheckResults(isSubset == r)
   }
-
-  var isSubset = false
-  for _ in 0 ..< N * 5000 {
-    isSubset = set.isSubset(of: otherSet)
-    if isSubset {
-      break
-    }
-  }
-
-  CheckResults(!isSubset)
 }
 
 @inline(never)
-func sink(_ s: inout Set<Box<Int>>) {
+func run_SetSymmetricDifferenceBox(
+  _ a: Set<Box<Int>>,
+  _ b: Set<Box<Int>>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let diff = a.symmetricDifference(identity(b))
+    CheckResults(diff.count == r)
+  }
 }
 
 @inline(never)
-public func run_SetExclusiveOr_OfObjects(_ N: Int) {
-  let size = 400
-
-  SRand()
-
-  var set = Set<Box<Int>>(minimumCapacity: size)
-  var otherSet = Set<Box<Int>>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Box(Int(truncatingIfNeeded: Random())))
-    otherSet.insert(Box(Int(truncatingIfNeeded: Random())))
-  }
-
-  var xor = Set<Box<Int>>()
-  for _ in 0 ..< N * 100 {
-    xor = set.symmetricDifference(otherSet)
+func run_SetUnionBox(
+  _ a: Set<Box<Int>>,
+  _ b: Set<Box<Int>>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let or = a.union(identity(b))
+    CheckResults(or.count == r)
   }
-  sink(&xor)
 }
 
 @inline(never)
-public func run_SetUnion_OfObjects(_ N: Int) {
-  let size = 400
-
-  SRand()
-
-  var set = Set<Box<Int>>(minimumCapacity: size)
-  var otherSet = Set<Box<Int>>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Box(Int(truncatingIfNeeded: Random())))
-    otherSet.insert(Box(Int(truncatingIfNeeded: Random())))
-  }
-
-  var or = Set<Box<Int>>()
-  for _ in 0 ..< N * 100 {
-    or = set.union(otherSet)
+func run_SetIntersectionBox(
+  _ a: Set<Box<Int>>,
+  _ b: Set<Box<Int>>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let and = a.intersection(b)
+    CheckResults(and.count == r)
   }
-  sink(&or)
 }
 
 @inline(never)
-public func run_SetIntersect_OfObjects(_ N: Int) {
-  let size = 400
-
-  SRand()
-
-  var set = Set<Box<Int>>(minimumCapacity: size)
-  var otherSet = Set<Box<Int>>(minimumCapacity: size)
-
-  for _ in 0 ..< size {
-    set.insert(Box(Int(truncatingIfNeeded: Random())))
-    otherSet.insert(Box(Int(truncatingIfNeeded: Random())))
-  }
-
-  var and = Set<Box<Int>>()
-  for _ in 0 ..< N * 100 {
-    and = set.intersection(otherSet)
+func run_SetSubtractingBox(
+  _ a: Set<Box<Int>>,
+  _ b: Set<Box<Int>>,
+  _ r: Int,
+  _ n: Int) {
+  for _ in 0 ..< n {
+    let and = a.subtracting(b)
+    CheckResults(and.count == r)
   }
-  sink(&and)
 }