[perf] add text sizing cache

Author: honghaoz

ComposeUI/Sources/ComposeUI/Extensions/NSAttributedString+Sizing.swift

@@ -43,6 +43,8 @@ extension NSAttributedString {
 
   /// Calculate the bounding size of the attributed string.
   ///
+  /// The text size is cached based on the attributed string and the layout parameters. Use `computeBoundingRectSize` to bypass the cache.
+  ///
   /// Related: https://github.com/honghaoz/ChouTiUI/blob/c2cc7b8452d269d6ee55993a977ed4b5fabf15d4/ChouTiUI/Sources/ChouTiUI/Universal/Text/TextSizeProvider.swift#L258
   ///
   /// - Parameters:
@@ -55,6 +57,35 @@ extension NSAttributedString {
       return .zero
     }
 
+    // single-line sizing measures the natural, unwrapped line, so its size is independent of `layoutWidth` and `lineBreakMode`
+    // see `computeBoundingRectSize` for more details.
+    //
+    // normalize `layoutWidth` and `lineBreakMode` so the same single-line text resolves to one cache entry regardless of width / mode.
+    let keyLayoutWidth = numberOfLines == 1 ? 0 : layoutWidth
+    let keyLineBreakMode: NSLineBreakMode = numberOfLines == 1 ? .byWordWrapping : lineBreakMode
+
+    let key = TextSizeCache.Key(attributedString: self, numberOfLines: numberOfLines, layoutWidth: keyLayoutWidth, lineBreakMode: keyLineBreakMode)
+    if let cached = TextSizeCache.shared.object(forKey: key) {
+      return cached.size
+    }
+
+    let size = computeBoundingRectSize(numberOfLines: numberOfLines, layoutWidth: layoutWidth, lineBreakMode: lineBreakMode)
+    TextSizeCache.shared.setObject(TextSizeCache.Value(size), forKey: key)
+    return size
+  }
+
+  /// Calculate the bounding size of the attributed string. No cache is used.
+  ///
+  /// - Parameters:
+  ///   - numberOfLines: The number of lines to calculate the bounding size for. Use 0 for unlimited lines.
+  ///   - layoutWidth: The width of the layout.
+  ///   - lineBreakMode: The line break mode to use for the layout. Default is `byWordWrapping`.
+  /// - Returns: The bounding size of the attributed string.
+  func computeBoundingRectSize(numberOfLines: Int, layoutWidth: CGFloat, lineBreakMode: NSLineBreakMode = .byWordWrapping) -> CGSize {
+    guard self.length > 0 else {
+      return .zero
+    }
+
     if numberOfLines == 1 {
       return singleLineTextBoundingRectSize()
     }
@@ -263,6 +294,87 @@ extension NSAttributedString {
   //  }
 }
 
+// MARK: - Text Size Cache
+
+extension NSAttributedString {
+
+  /// Removes all cached text sizes.
+  static func clearTextSizeCache() {
+    TextSizeCache.shared.removeAllObjects()
+  }
+}
+
+/// A process-wide cache for `NSAttributedString.boundingRectSize`.
+private enum TextSizeCache {
+
+  /// The shared cache. `NSCache` is thread-safe and evicts entries under memory pressure.
+  static let shared: NSCache<Key, Value> = {
+    let cache = NSCache<Key, Value>()
+    cache.countLimit = Constants.countLimit
+    return cache
+  }()
+
+  /// A cache key capturing every input that affects the text size.
+  final class Key: NSObject {
+
+    let attributedString: NSAttributedString
+    let numberOfLines: Int
+    let layoutWidth: CGFloat
+    let lineBreakMode: NSLineBreakMode
+
+    private let hashCode: Int
+
+    init(attributedString: NSAttributedString, numberOfLines: Int, layoutWidth: CGFloat, lineBreakMode: NSLineBreakMode) {
+      // callers may pass an `NSMutableAttributedString`, and a cache key's hash and equality must stay stable while it
+      // lives in the cache, otherwise a later mutation of the same instance would leave the key in the wrong hash bucket
+      // (a stale/leaked entry, and a wrong hit under a hash collision).
+      let snapshot = (attributedString.copy() as? NSAttributedString) ?? attributedString
+      self.attributedString = snapshot
+      self.numberOfLines = numberOfLines
+      self.layoutWidth = layoutWidth
+      self.lineBreakMode = lineBreakMode
+
+      var hasher = Hasher()
+      hasher.combine(snapshot)
+      hasher.combine(numberOfLines)
+      hasher.combine(layoutWidth)
+      hasher.combine(lineBreakMode.rawValue)
+      hashCode = hasher.finalize()
+    }
+
+    override var hash: Int {
+      hashCode
+    }
+
+    override func isEqual(_ object: Any?) -> Bool {
+      guard let other = object as? Key else {
+        return false
+      }
+      // compare the cheap scalars before the (more expensive) attributed string contents.
+      return numberOfLines == other.numberOfLines
+        && layoutWidth == other.layoutWidth
+        && lineBreakMode == other.lineBreakMode
+        && attributedString.isEqual(other.attributedString)
+    }
+  }
+
+  /// A boxed `CGSize` so it can be stored in `NSCache` (which requires class values).
+  final class Value {
+
+    let size: CGSize
+
+    init(_ size: CGSize) {
+      self.size = size
+    }
+  }
+
+  private enum Constants {
+
+    /// Upper bound on cached entries; `NSCache` evicts beyond this (and under memory pressure).
+    static let countLimit = 4096
+  }
+}
+
 // Notes on CoreText API:
 //
 // 1. CTFramesetterSuggestFrameSizeWithConstraints:

ComposeUI/Tests/ComposeUITests/CrossPlatform/BaseTextViewTests.swift

@@ -122,7 +122,7 @@ class BaseTextViewTests: XCTestCase {
     expect(window.firstResponder) !== textView
     #endif
 
-    #if canImport(UIKit)
+    #if canImport(UIKit) && !os(tvOS)
     let textView = BaseTextView(frame: CGRect(x: 0, y: 0, width: 200, height: 50))
     let window = TestWindow()
     window.rootViewController = UIViewController()

ComposeUI/Tests/ComposeUITests/Extensions/NSAttributedString+SizingTests.swift

@@ -866,6 +866,106 @@ class NSAttributedString_SizingTests: XCTestCase {
     #endif
   }
 
+  // MARK: - Cache
+
+  func test_cache_cachedMatchesUncached_singleLine() throws {
+    NSAttributedString.clearTextSizeCache()
+
+    let attributedString = try makeAttributedString(font: Font.systemFont(ofSize: 16), lineBreakMode: .byWordWrapping)
+
+    let uncached = attributedString.computeBoundingRectSize(numberOfLines: 1, layoutWidth: 100)
+    let cachedMiss = attributedString.boundingRectSize(numberOfLines: 1, layoutWidth: 100) // computes + caches
+    let cachedHit = attributedString.boundingRectSize(numberOfLines: 1, layoutWidth: 100) // served from cache
+
+    expect(cachedMiss) == uncached
+    expect(cachedHit) == uncached
+  }
+
+  func test_cache_cachedMatchesUncached_multiLine() throws {
+    NSAttributedString.clearTextSizeCache()
+
+    let attributedString = try makeAttributedString(font: Font.systemFont(ofSize: 16), lineBreakMode: .byWordWrapping)
+
+    let uncached = attributedString.computeBoundingRectSize(numberOfLines: 0, layoutWidth: 100)
+    let cachedMiss = attributedString.boundingRectSize(numberOfLines: 0, layoutWidth: 100)
+    let cachedHit = attributedString.boundingRectSize(numberOfLines: 0, layoutWidth: 100)
+
+    expect(cachedMiss) == uncached
+    expect(cachedHit) == uncached
+  }
+
+  func test_cache_distinctFonts_notConfused() throws {
+    NSAttributedString.clearTextSizeCache()
+
+    // same text, different font: the key includes the attributed string (which carries the font), so the two sizes
+    // must not collapse to one cached entry.
+    let small = try makeAttributedString(font: Font.systemFont(ofSize: 16), lineBreakMode: .byWordWrapping)
+    let large = try makeAttributedString(font: Font.systemFont(ofSize: 32), lineBreakMode: .byWordWrapping)
+
+    let smallSize = small.boundingRectSize(numberOfLines: 1, layoutWidth: 100)
+    let largeSize = large.boundingRectSize(numberOfLines: 1, layoutWidth: 100)
+
+    expect(smallSize) != largeSize
+    expect(largeSize.height) > smallSize.height
+  }
+
+  func test_cache_distinctWidths_notConfused() throws {
+    NSAttributedString.clearTextSizeCache()
+
+    // same multi-line text at different widths wraps differently, so the cache (keyed by width) must keep them distinct.
+    let attributedString = try makeAttributedString(font: Font.systemFont(ofSize: 16), lineBreakMode: .byWordWrapping)
+
+    let narrow = attributedString.boundingRectSize(numberOfLines: 0, layoutWidth: 80)
+    let wide = attributedString.boundingRectSize(numberOfLines: 0, layoutWidth: 300)
+
+    expect(narrow) != wide
+    expect(narrow.height) > wide.height // narrower wraps to more lines -> taller
+  }
+
+  func test_cache_clear_recomputesSameValue() throws {
+    let attributedString = try makeAttributedString(font: Font.systemFont(ofSize: 16), lineBreakMode: .byWordWrapping)
+
+    let before = attributedString.boundingRectSize(numberOfLines: 2, layoutWidth: 120)
+    NSAttributedString.clearTextSizeCache()
+    let after = attributedString.boundingRectSize(numberOfLines: 2, layoutWidth: 120)
+
+    expect(after) == before
+  }
+
+  func test_cache_mutableAttributedString_afterMutation_returnsNewSize() throws {
+    NSAttributedString.clearTextSizeCache()
+
+    let attributes: [NSAttributedString.Key: Any] = [.font: Font.systemFont(ofSize: 16)]
+    let mutableString = NSMutableAttributedString(string: "Hi", attributes: attributes)
+
+    let sizeBeforeMutation = mutableString.boundingRectSize(numberOfLines: 1, layoutWidth: 1000)
+
+    // mutate the same instance that was just used as a cache key, then ask again with that same instance.
+    mutableString.append(NSAttributedString(string: " there, this is a much longer piece of text", attributes: attributes))
+    let sizeAfterMutation = mutableString.boundingRectSize(numberOfLines: 1, layoutWidth: 1000)
+
+    // the size must reflect the mutated (longer) content, not a stale value keyed by the pre-mutation string.
+    expect(sizeAfterMutation) != sizeBeforeMutation
+    expect(sizeAfterMutation.width) > sizeBeforeMutation.width
+    expect(sizeAfterMutation) == mutableString.computeBoundingRectSize(numberOfLines: 1, layoutWidth: 1000)
+  }
+
+  func test_cache_singleLine_sizeIndependentOfWidthAndLineBreakMode() throws {
+    NSAttributedString.clearTextSizeCache()
+
+    // single-line sizing ignores layoutWidth and lineBreakMode (it measures the natural, unwrapped line)
+    let attributedString = try makeAttributedString(font: Font.systemFont(ofSize: 16), lineBreakMode: .byWordWrapping)
+
+    let narrow = attributedString.boundingRectSize(numberOfLines: 1, layoutWidth: 50)
+    let wide = attributedString.boundingRectSize(numberOfLines: 1, layoutWidth: 5000)
+    let charWrap = attributedString.boundingRectSize(numberOfLines: 1, layoutWidth: 123, lineBreakMode: .byCharWrapping)
+
+    expect(narrow) == wide
+    expect(narrow) == charWrap
+  }
+
+  // MARK: - Helpers
+
   private func makeAttributedString(font: Font, lineBreakMode: NSLineBreakMode) throws -> NSAttributedString {
     NSAttributedString(
       string: Constants.string,