[String] More efficient breadcrumb-scanning code.

Rather than rely on the UTF16View, scan between breadcrumbs by hand
for a decent 20% speedup. This code will also make it more obvious how
to slot in a vectorized solution later.

Author: milseman

stdlib/public/core/StringUTF16View.swift

@@ -186,8 +186,8 @@ extension String.UTF16View: BidirectionalCollection {
       return _foreignIndex(i, offsetBy: n)
     }
 
-    let lowerOffset = _getOffset(for: i)
-    let result = _getIndex(for: lowerOffset + n)
+    let lowerOffset = _nativeGetOffset(for: i)
+    let result = _nativeGetIndex(for: lowerOffset + n)
     return result
   }
 
@@ -199,8 +199,8 @@ extension String.UTF16View: BidirectionalCollection {
       return _foreignIndex(i, offsetBy: n, limitedBy: limit)
     }
 
-    let iOffset = _getOffset(for: i)
-    let limitOffset = _getOffset(for: limit)
+    let iOffset = _nativeGetOffset(for: i)
+    let limitOffset = _nativeGetOffset(for: limit)
 
     // If distance < 0, limit has no effect if it is greater than i.
     if _slowPath(n < 0 && limit <= i && limitOffset > iOffset + n) {
@@ -211,7 +211,7 @@ extension String.UTF16View: BidirectionalCollection {
       return nil
     }
 
-    let result = _getIndex(for: iOffset + n)
+    let result = _nativeGetIndex(for: iOffset + n)
     return result
   }
 
@@ -221,8 +221,8 @@ extension String.UTF16View: BidirectionalCollection {
       return _foreignDistance(from: start, to: end)
     }
 
-    let lower = _getOffset(for: start)
-    let upper = _getOffset(for: end)
+    let lower = _nativeGetOffset(for: start)
+    let upper = _nativeGetOffset(for: end)
     return upper &- lower
   }
 
@@ -231,7 +231,7 @@ extension String.UTF16View: BidirectionalCollection {
     if _slowPath(_guts.isForeign) {
       return _foreignCount()
     }
-    return _getOffset(for: endIndex)
+    return _nativeGetOffset(for: endIndex)
   }
 
   /// Accesses the code unit at the given position.
@@ -458,7 +458,7 @@ extension String.UTF16View {
 
   @usableFromInline
   @_effects(releasenone)
-  internal func _getOffset(for idx: Index) -> Int {
+  internal func _nativeGetOffset(for idx: Index) -> Int {
     // Trivial and common: start
     if idx == startIndex { return 0 }
 
@@ -478,7 +478,7 @@ extension String.UTF16View {
 
   @usableFromInline
   @_effects(releasenone)
-  internal func _getIndex(for offset: Int) -> Index {
+  internal func _nativeGetIndex(for offset: Int) -> Index {
     // Trivial and common: start
     if offset == 0 { return startIndex }
 
@@ -493,7 +493,40 @@ extension String.UTF16View {
     // Otherwise, find the nearest lower-bound breadcrumb and advance that
     let (crumb, remaining) = breadcrumbsPtr.pointee.getBreadcrumb(
       forOffset: offset)
-    return _index(crumb, offsetBy: remaining)
+    if remaining == 0 { return crumb }
+
+    return _guts.withFastUTF8 { utf8 in
+      var readIdx = crumb.encodedOffset
+      var readEnd = utf8.count
+      _sanityCheck(readIdx < readEnd)
+
+      var utf16I = 0
+      let utf16End: Int = remaining
+
+      // Adjust for sub-scalar initial transcoding: If we're starting the scan
+      // at a trailing surrogate, then we set our starting count to be -1 so as
+      // offset counting the leading surrogate.
+      if crumb.transcodedOffset != 0 {
+        utf16I = -1
+      }
+
+      while true {
+        let len = _utf8ScalarLength(utf8[readIdx])
+        let utf16Len = len == 4 ? 2 : 1
+        utf16I &+= utf16Len
+
+        if utf16I >= utf16End {
+          // Uncommon: final sub-scalar transcoded offset
+          if _slowPath(utf16I > utf16End) {
+            _sanityCheck(utf16Len == 2)
+            return Index(encodedOffset: readIdx, transcodedOffset: 1)
+          }
+          return Index(encodedOffset: readIdx &+ len)
+        }
+
+        readIdx &+= len
+      }
+    }
   }
 }
 

validation-test/stdlib/StringBreadcrumbs.swift

@@ -28,42 +28,64 @@ let largeString: String = {
   return result
 }()
 
+extension FixedWidthInteger {
+  var hexStr: String { return "0x\(String(self, radix: 16, uppercase: true))" }
+}
+
 let StringBreadcrumbsTests = TestSuite("StringBreadcrumbsTests")
 
-StringBreadcrumbsTests.test("largeString") {
-  var utf16CodeUnits = Array(largeString.utf16)
-  var utf16Indices = Array(largeString.utf16.indices)
+func validateBreadcrumbs(_ str: String) {
+  var utf16CodeUnits = Array(str.utf16)
+  var utf16Indices = Array(str.utf16.indices)
   var outputBuffer = Array<UInt16>(repeating: 0, count: utf16CodeUnits.count)
 
   for i in 0..<(utf16CodeUnits.count-1) {
     for j in (i+1)..<utf16CodeUnits.count {
       let range = Range(uncheckedBounds: (i, j))
-      let indexRange = largeString._toUTF16Indices(range)
 
-      // Range<String.Index> from Range<Int>
+      let indexRange = str._toUTF16Indices(range)
+      // Range<String.Index> <=> Range<Int>
+      expectEqual(utf16Indices[i], indexRange.lowerBound)
+      expectEqual(utf16Indices[j], indexRange.upperBound)
       expectEqualSequence(
-        utf16CodeUnits[i..<j], largeString.utf16[indexRange])
+        utf16CodeUnits[i..<j], str.utf16[indexRange])
+      let roundTripOffsets = str._toUTF16Offsets(indexRange)
+      expectEqualSequence(range, roundTripOffsets)
 
-      // Copy characters      
+      // Single Int <=> String.Index
+      expectEqual(indexRange.lowerBound, str._toUTF16Index(i))
+      expectEqual(indexRange.upperBound, str._toUTF16Index(j))
+      expectEqual(i, str._toUTF16Offset(indexRange.lowerBound))
+      expectEqual(j, str._toUTF16Offset(indexRange.upperBound))
+
+      // Copy characters
       outputBuffer.withUnsafeMutableBufferPointer {
-        largeString._copyUTF16CodeUnits(into: $0, range: range)
+        str._copyUTF16CodeUnits(into: $0, range: range)
       }
       expectEqualSequence(utf16CodeUnits[i..<j], outputBuffer[..<range.count])
-
-      // Range<Int> from Range<String.Index>
-      let roundTripOffsets = largeString._toUTF16Offsets(indexRange)
-      expectEqualSequence(range, roundTripOffsets)
-
-      // Single Int <=> String.Index
-      expectEqual(indexRange.lowerBound, largeString._toUTF16Index(i))
-      expectEqual(indexRange.upperBound, largeString._toUTF16Index(j))
-      expectEqual(i, largeString._toUTF16Offset(indexRange.lowerBound))
-      expectEqual(j, largeString._toUTF16Offset(indexRange.upperBound))
     }
   }
 }
 
-// TODO(String testing): hammer breadcrumb boundaries more, maybe internals too
+StringBreadcrumbsTests.test("largeString") {
+  validateBreadcrumbs(largeString)
+}
 
-runAllTests()
+// Test various boundary conditions with surrogate pairs aligning or not
+// aligning
+StringBreadcrumbsTests.test("surrogates-heavy") {
+  let nonBMP = String(repeating: "𓀀", count: 1 + (64 / 2))
 
+  // Mis-align the hieroglyphics by 1,2,3 UTF-8 and UTF-16 code units
+  validateBreadcrumbs(nonBMP)
+  validateBreadcrumbs("a" + nonBMP)
+  validateBreadcrumbs("ab" + nonBMP)
+  validateBreadcrumbs("abc" + nonBMP)
+  validateBreadcrumbs("é" + nonBMP)
+  validateBreadcrumbs("是" + nonBMP)
+  validateBreadcrumbs("aé" + nonBMP)
+}
+
+// TODO(String testing): test breadcrumb validity after mutation
+
+runAllTests()