[stdlib]String normalization functions

benchmark/single-source/StringComparison.swift

@@ -150,58 +150,58 @@ public let StringHashing: [BenchmarkInfo] = [
   ),
 ]
 
-public let NormalizedIterator: [BenchmarkInfo] = [
+public let StringNormalization: [BenchmarkInfo] = [
   BenchmarkInfo(
     name: "NormalizedIterator_ascii",
-    runFunction: run_NormalizedIterator_ascii,
+    runFunction: run_StringNormalization_ascii,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_ascii) }
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_latin1",
-    runFunction: run_NormalizedIterator_latin1,
+    runFunction: run_StringNormalization_latin1,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_latin1) },
 		legacyFactor: 2
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_fastPrenormal",
-    runFunction: run_NormalizedIterator_fastPrenormal,
+    runFunction: run_StringNormalization_fastPrenormal,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_fastPrenormal) },
 		legacyFactor: 10
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_slowerPrenormal",
-    runFunction: run_NormalizedIterator_slowerPrenormal,
+    runFunction: run_StringNormalization_slowerPrenormal,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_slowerPrenormal) },
 		legacyFactor: 10
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_nonBMPSlowestPrenormal",
-    runFunction: run_NormalizedIterator_nonBMPSlowestPrenormal,
+    runFunction: run_StringNormalization_nonBMPSlowestPrenormal,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_nonBMPSlowestPrenormal) },
 		legacyFactor: 10
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_emoji",
-    runFunction: run_NormalizedIterator_emoji,
+    runFunction: run_StringNormalization_emoji,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_emoji) },
 		legacyFactor: 4
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_abnormal",
-    runFunction: run_NormalizedIterator_abnormal,
+    runFunction: run_StringNormalization_abnormal,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_abnormal) },
 		legacyFactor: 20
   ),
   BenchmarkInfo(
     name: "NormalizedIterator_zalgo",
-    runFunction: run_NormalizedIterator_zalgo,
+    runFunction: run_StringNormalization_zalgo,
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_zalgo) },
 		legacyFactor: 25
@@ -452,7 +452,7 @@ public func run_StringHashing_zalgo(_ N: Int) {
 
 
 @inline(never)
-public func run_NormalizedIterator_ascii(_ N: Int) {
+public func run_StringNormalization_ascii(_ N: Int) {
   let workload: Workload = Workload.ascii
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -466,7 +466,7 @@ public func run_NormalizedIterator_ascii(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_latin1(_ N: Int) {
+public func run_StringNormalization_latin1(_ N: Int) {
   let workload: Workload = Workload.latin1
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -480,7 +480,7 @@ public func run_NormalizedIterator_latin1(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_fastPrenormal(_ N: Int) {
+public func run_StringNormalization_fastPrenormal(_ N: Int) {
   let workload: Workload = Workload.fastPrenormal
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -494,7 +494,7 @@ public func run_NormalizedIterator_fastPrenormal(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_slowerPrenormal(_ N: Int) {
+public func run_StringNormalization_slowerPrenormal(_ N: Int) {
   let workload: Workload = Workload.slowerPrenormal
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -508,7 +508,7 @@ public func run_NormalizedIterator_slowerPrenormal(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_nonBMPSlowestPrenormal(_ N: Int) {
+public func run_StringNormalization_nonBMPSlowestPrenormal(_ N: Int) {
   let workload: Workload = Workload.nonBMPSlowestPrenormal
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -522,7 +522,7 @@ public func run_NormalizedIterator_nonBMPSlowestPrenormal(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_emoji(_ N: Int) {
+public func run_StringNormalization_emoji(_ N: Int) {
   let workload: Workload = Workload.emoji
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -536,7 +536,7 @@ public func run_NormalizedIterator_emoji(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_abnormal(_ N: Int) {
+public func run_StringNormalization_abnormal(_ N: Int) {
   let workload: Workload = Workload.abnormal
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -550,7 +550,7 @@ public func run_NormalizedIterator_abnormal(_ N: Int) {
 }
 
 @inline(never)
-public func run_NormalizedIterator_zalgo(_ N: Int) {
+public func run_StringNormalization_zalgo(_ N: Int) {
   let workload: Workload = Workload.zalgo
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -564,6 +564,7 @@ public func run_NormalizedIterator_zalgo(_ N: Int) {
 }
 
 
+
 struct Workload {
   static let N = 100
 

benchmark/single-source/StringComparison.swift.gyb

@@ -35,7 +35,7 @@ AllWorkloads = ["ascii", "latin1", "fastPrenormal", "slowerPrenormal",
                 "longSharedPrefix"]
 ComparisonWorkloads = AllWorkloads
 HashingWorkloads = AllWorkloads[:-1]
-NormalizedIteratorWorkloads = AllWorkloads[:-1]
+NormalizationWorkloads = AllWorkloads[:-1]
 
 LegacyFactor = dict(abnormal=20, emoji=4, latin1=2, fastPrenormal=10,
                     slowerPrenormal=10, nonBMPSlowestPrenormal=10, zalgo=25)
@@ -68,15 +68,15 @@ public let StringHashing: [BenchmarkInfo] = [
 % end # HashingWorkloads
 ]
 
-public let NormalizedIterator: [BenchmarkInfo] = [
-% for Name in NormalizedIteratorWorkloads:
+public let StringNormalization: [BenchmarkInfo] = [
+% for Name in NormalizationWorkloads:
   BenchmarkInfo(
     name: "NormalizedIterator_${Name}",
-    runFunction: run_NormalizedIterator_${Name},
+    runFunction: run_StringNormalization_${Name},
     tags: [.validation, .String],
     setUpFunction: { blackHole(Workload_${Name}) }${legacyFactor(Name)}
   ),
-% end # NormalizedIteratorWorkloads
+% end # NormalizationWorkloads
 ]
 
 % for Name in AllWorkloads:
@@ -116,9 +116,9 @@ public func run_StringHashing_${Name}(_ N: Int) {
 
 % end # HashingWorkloads
 
-%for Name in NormalizedIteratorWorkloads:
+%for Name in NormalizationWorkloads:
 @inline(never)
-public func run_NormalizedIterator_${Name}(_ N: Int) {
+public func run_StringNormalization_${Name}(_ N: Int) {
   let workload: Workload = Workload.${Name}
   let tripCount = workload.tripCount
   let payload = workload.payload
@@ -131,7 +131,8 @@ public func run_NormalizedIterator_${Name}(_ N: Int) {
   }
 }
 
-% end # NormalizedIteratorWorkloads
+% end # NormalizationWorkloads
+
 
 struct Workload {
   static let N = 100

benchmark/utils/main.swift

@@ -270,7 +270,6 @@ registerBenchmark(NSErrorTest)
 registerBenchmark(NSStringConversion)
 registerBenchmark(NibbleSort)
 registerBenchmark(NopDeinit)
-registerBenchmark(NormalizedIterator)
 registerBenchmark(ObjectAllocation)
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 registerBenchmark(ObjectiveCBridging)
@@ -332,6 +331,7 @@ registerBenchmark(StringInterpolation)
 registerBenchmark(StringInterpolationSmall)
 registerBenchmark(StringInterpolationManySmallSegments)
 registerBenchmark(StringMatch)
+registerBenchmark(StringNormalization)
 registerBenchmark(StringRemoveDupes)
 registerBenchmark(StringTests)
 registerBenchmark(StringWalk)

stdlib/public/core/CMakeLists.txt

@@ -101,7 +101,6 @@ set(SWIFTLIB_ESSENTIAL
   NativeDictionary.swift
   NativeSet.swift
   NewtypeWrapper.swift
-  NormalizedCodeUnitIterator.swift
   ObjectIdentifier.swift
   Optional.swift
   OptionSet.swift