[string] Shrink storage class sizes.

* Don't allocate breadrumbs pointer if under threshold
* Increase breadrumbs threshold
* Linear 16-byte bucketing until 128 bytes, malloc_size after
* Allow cap less than _SmallString.capacity (bridging non-ASCII)

This change decreases the amount of heap usage for moderate-length
strings (< 64 UTF-8 code units in length) and increases the amount of
spare code unit capacity available (less growth needed).

Average improvements for moderate-length strings:

* 64-bit: on average, 8 bytes saved and 4 bytes of extra capacity
* 32-bit: on average, 4 bytes saved and 6 bytes of extra capacity

Additionally, on 32-bit, large-length strings also gain an average of
6 bytes of extra spare capacity.

Details:

On 64-bit, half of moderate-length allocations will save 16 bytes
while the other half get an extra 8 bytes of spare capacity.

On 32-bit, a quarter of moderate-length allocations will save 16
bytes, and the rest get an extra 4 bytes of spare
capacity. Additionally, 32-bit string's storage class now claims its
full allocation, which is its birthright. Prior to this change, we'd
have on average 1.5 bytes of spare capacity, and now we have 7.5 bytes
of spare capacity.

Breadcrumbs threshold is increased from the super-conservative 32 to
the pretty-conservative 64. Some speed improvements are incorporated
in this change, but more are in flight. Even without those eventual
improvements, this is a worthwhile change (ASCII is still fast-pathed
and irrelevant to breadcrumbing).

For a complex real-world workload, this amounts to around a 5%
improvement to transient heap usage due to all strings and a 4%
improvement to peak heap usage due to all strings. For moderate-length
strings specifically, this gives around 11% improvement to both.

Author: milseman

stdlib/public/core/LegacyABI.swift

@@ -79,3 +79,11 @@ extension String {
     range: Range<String.Index>
   ) { fatalError() }
 }
+
+extension String.UTF16View {
+  // Swift 5.x: This was accidentally shipped as inlinable, but was never used
+  // from an inlinable context. The definition is kept around for techincal ABI
+  // compatibility (even though it shouldn't matter), but is unused.
+  @inlinable @inline(__always)
+  internal var _shortHeuristic: Int { return 32 }
+}

stdlib/public/core/StringBreadcrumbs.swift

@@ -13,16 +13,16 @@
 
 // @opaque
 internal final class _StringBreadcrumbs {
-  static var breadcrumbStride: Int { return 32 }
+  internal static var breadcrumbStride: Int { 64 }
 
-  var utf16Length: Int
+  internal var utf16Length: Int
 
   // TODO: does this need to be a pair?.... Can we be smaller than Int?
-  var crumbs: [String.Index]
+  internal var crumbs: [String.Index]
 
   // TODO: Does this need to be inout, unique, or how will we be enforcing
   // atomicity?
-  init(_ str: String) {
+  internal init(_ str: String) {
     let stride = _StringBreadcrumbs.breadcrumbStride
 
     self.crumbs = []
@@ -62,7 +62,7 @@ internal final class _StringBreadcrumbs {
 }
 
 extension _StringBreadcrumbs {
-  var stride: Int {
+  internal var stride: Int {
     @inline(__always) get { return _StringBreadcrumbs.breadcrumbStride }
   }
 
@@ -108,37 +108,3 @@ extension _StringBreadcrumbs {
   #endif // INTERNAL_CHECKS_ENABLED
 }
 
-extension _StringGuts {
-  @_effects(releasenone)
-  internal func getBreadcrumbsPtr() -> UnsafePointer<_StringBreadcrumbs> {
-    _internalInvariant(hasBreadcrumbs)
-
-    let mutPtr: UnsafeMutablePointer<_StringBreadcrumbs?>
-    if hasNativeStorage {
-      mutPtr = _object.nativeStorage._breadcrumbsAddress
-    } else {
-      mutPtr = UnsafeMutablePointer(
-        Builtin.addressof(&_object.sharedStorage._breadcrumbs))
-    }
-
-    if _slowPath(mutPtr.pointee == nil) {
-      populateBreadcrumbs(mutPtr)
-    }
-
-    _internalInvariant(mutPtr.pointee != nil)
-    // assuming optional class reference and class reference can alias
-    return UnsafeRawPointer(mutPtr).assumingMemoryBound(to: _StringBreadcrumbs.self)
-  }
-
-  @inline(never) // slow-path
-  @_effects(releasenone)
-  internal func populateBreadcrumbs(
-    _ mutPtr: UnsafeMutablePointer<_StringBreadcrumbs?>
-  ) {
-    // Thread-safe compare-and-swap
-    let crumbs = _StringBreadcrumbs(String(self))
-    _stdlib_atomicInitializeARCRef(
-      object: UnsafeMutableRawPointer(mutPtr).assumingMemoryBound(to: Optional<AnyObject>.self), 
-      desired: crumbs)
-  }
-}

stdlib/public/core/StringBridge.swift

@@ -462,6 +462,7 @@ extension String {
         // and bridge that instead. Also avoids CF deleting any BOM that may be
         // present
         var copy = self
+        // TODO: small capacity minimum is lifted, just need to make native
         copy._guts.grow(_SmallString.capacity + 1)
         _internalInvariant(!copy._guts.isSmall)
         return copy._bridgeToObjectiveCImpl()

stdlib/public/core/StringCreate.swift

@@ -109,7 +109,7 @@ extension String {
     ) throws -> Int
   ) rethrows -> String {
     let result = try __StringStorage.create(
-      uninitializedCapacity: capacity,
+      uninitializedCodeUnitCapacity: capacity,
       initializingUncheckedUTF8With: initializer)
 
     switch validateUTF8(result.codeUnits) {

stdlib/public/core/StringGuts.swift

@@ -120,8 +120,10 @@ extension _StringGuts {
 
   internal var hasSharedStorage: Bool { return _object.hasSharedStorage }
 
+  // Whether this string has breadcrumbs
   internal var hasBreadcrumbs: Bool {
-    return hasNativeStorage || hasSharedStorage
+    return hasSharedStorage
+      || (hasNativeStorage && _object.nativeStorage.hasBreadcrumbs)
   }
 }
 

stdlib/public/core/StringGutsRangeReplaceable.swift

@@ -79,13 +79,16 @@ extension _StringGuts {
     _internalInvariant(
       self.uniqueNativeCapacity == nil || self.uniqueNativeCapacity! < n)
 
+    // TODO: Dont' do this! Growth should only happen for append...
     let growthTarget = Swift.max(n, (self.uniqueNativeCapacity ?? 0) * 2)
 
     if _fastPath(isFastUTF8) {
       let isASCII = self.isASCII
       let storage = self.withFastUTF8 {
         __StringStorage.create(
-          initializingFrom: $0, capacity: growthTarget, isASCII: isASCII)
+          initializingFrom: $0,
+          codeUnitCapacity: growthTarget,
+          isASCII: isASCII)
       }
 
       self = _StringGuts(storage)