[perf] improve ComposeNodeId speed

Author: honghaoz

ComposeUI/Sources/ComposeUI/ComposeNode/ComposeNode.swift

@@ -43,8 +43,7 @@ public protocol ComposeNode: ComposeContent {
   ///
   /// The id must be unique for a node type.
   ///
-  /// For your own node type, don't use `.standard` id. Instead, use `.custom`
-  /// with a prefix to avoid conflicts.
+  /// For your own node type, use `.custom` with a prefix to avoid conflicts.
   ///
   /// For example, if you have a `MyCustomNode`, you can use id like
   /// `.custom("com.myapp.mycustomnode", isFixed: false)`.
@@ -122,7 +121,7 @@ public extension ComposeNode {
   }
 
   private func id(_ id: ComposeNodeId) -> Self {
-    guard self.id != id else {
+    guard !self.id.isSameConfiguration(as: id) else {
       return self
     }
 

ComposeUI/Sources/ComposeUI/ComposeNode/ComposeNodeId.swift

@@ -59,7 +59,7 @@ enum StandardComposeNodeId: String {
   case composeView = "CV"
 }
 
-public struct ComposeNodeId: Equatable {
+public struct ComposeNodeId: Hashable {
 
   /// Create a custom id for a node.
   ///
@@ -81,13 +81,75 @@ public struct ComposeNodeId: Equatable {
   }
 
   /// The id of the node.
-  let id: String
+  public let id: String
 
   /// If the id is fixed.
   ///
   /// If the id is fixed, `join` will not add the parent node's id to the child node's id.
   private let isFixed: Bool
 
+  /// A precomputed 64-bit hash of `id`.
+  ///
+  /// `ComposeView` uses node ids as render-pass dictionary/set keys. Caching this value keeps dictionary probes from
+  /// repeatedly hashing long composed id strings, while equality still checks the exact string so collisions remain safe.
+  private let cachedHash: UInt64
+
+  private init(id: String, isFixed: Bool) {
+    self.id = id
+    self.isFixed = isFixed
+    self.cachedHash = Self.fnv1a(id)
+  }
+
+  private init(id: String, isFixed: Bool, cachedHash: UInt64) {
+    self.id = id
+    self.isFixed = isFixed
+    self.cachedHash = cachedHash
+  }
+
+  // MARK: - Hashable
+
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(cachedHash)
+  }
+
+  public static func == (lhs: ComposeNodeId, rhs: ComposeNodeId) -> Bool {
+    // A node id's identity is its composed `id` string. `isFixed` only controls how the id is composed (whether a parent
+    // prefix is added in `join`), not which item the id denotes, so it is intentionally excluded from equality. This
+    // matches the render diff's long-standing behavior of keying its maps by the id string only: a `fixedId("x")` item
+    // and a composed item that resolves to "x" are the same (conflicting) render item, not two distinct ones.
+    //
+    // The cheap precomputed hash is compared first to reject mismatches without touching the strings; the exact `id`
+    // compare then makes equality collision-free (two distinct ids that happen to share a hash are never treated equal).
+    lhs.cachedHash == rhs.cachedHash && lhs.id == rhs.id
+  }
+
+  func isSameConfiguration(as other: ComposeNodeId) -> Bool {
+    id == other.id && isFixed == other.isFixed
+  }
+
+  /// FNV-1a hash of the string's UTF-8 bytes.
+  ///
+  /// Used to derive `cachedHash` from `id`, so the same `id` always yields the same hash regardless of how it was
+  /// composed (keeping `Hashable` consistent with the exact `==`).
+  @inline(__always)
+  private static func fnv1a(_ string: String) -> UInt64 {
+    fnv1a(string, hash: HashConstants.fnvOffsetBasis)
+  }
+
+  @inline(__always)
+  private static func fnv1a(_ string: String, hash initialHash: UInt64) -> UInt64 {
+    var hash = initialHash
+    for byte in string.utf8 {
+      hash = fnv1a(byte, hash: hash)
+    }
+    return hash
+  }
+
+  @inline(__always)
+  private static func fnv1a(_ byte: UInt8, hash: UInt64) -> UInt64 {
+    (hash ^ UInt64(byte)) &* HashConstants.fnvPrime
+  }
+
   /// Make a `ComposeNodeId` by joining the current node's id with a child node's id.
   ///
   /// If the `childNodeId` is fixed, it will return the `childNodeId` directly.
@@ -101,10 +163,25 @@ public struct ComposeNodeId: Equatable {
       return childNodeId
     } else {
       if let suffix {
-        return ComposeNodeId(id: "\(id)|\(suffix)|\(childNodeId.id)", isFixed: isFixed)
+        var hash = Self.fnv1a(HashConstants.separator, hash: cachedHash)
+        hash = Self.fnv1a(suffix, hash: hash)
+        hash = Self.fnv1a(HashConstants.separator, hash: hash)
+        hash = Self.fnv1a(childNodeId.id, hash: hash)
+        return ComposeNodeId(id: "\(id)|\(suffix)|\(childNodeId.id)", isFixed: isFixed, cachedHash: hash)
       } else {
-        return ComposeNodeId(id: "\(id)|\(childNodeId.id)", isFixed: isFixed)
+        var hash = Self.fnv1a(HashConstants.separator, hash: cachedHash)
+        hash = Self.fnv1a(childNodeId.id, hash: hash)
+        return ComposeNodeId(id: "\(id)|\(childNodeId.id)", isFixed: isFixed, cachedHash: hash)
       }
     }
   }
 }
+
+// MARK: - Constants
+
+private enum HashConstants {
+
+  static let separator: UInt8 = 0x7C // "|"
+  static let fnvOffsetBasis: UInt64 = 0xCBF29CE484222325
+  static let fnvPrime: UInt64 = 0x00000100000001B3
+}

ComposeUI/Sources/ComposeUI/ComposeView/ComposeView+Debug.swift

@@ -85,7 +85,7 @@ public extension ComposeView {
       case renderDidInsertRenderable(item: RenderableItem, renderable: Renderable)
 
       /// The render pass is finished, all the renderable items are rendered, transition animations or animations may still be running.
-      case renderDidFinish(renderableItemIds: [String], renderableItemMap: [String: RenderableItem], renderableMap: [String: Renderable])
+      case renderDidFinish(renderableItemIds: [ComposeNodeId], renderableItemMap: [ComposeNodeId: RenderableItem], renderableMap: [ComposeNodeId: Renderable])
     }
 
     private weak var composeView: ComposeView?

ComposeUI/Sources/ComposeUI/ComposeView/ComposeView+ZOrder.swift

@@ -69,7 +69,7 @@ extension ComposeView {
   ///   - newIds: The renderable item ids of the current render pass, in z-order (back to front).
   ///   - reusingIds: The ids that are in both `oldIds` and `newIds`.
   /// - Returns: The z-order plan.
-  static func makeZOrderPlan(oldIds: [String], newIds: [String], reusingIds: Set<String>) -> ZOrderPlan {
+  static func makeZOrderPlan(oldIds: [ComposeNodeId], newIds: [ComposeNodeId], reusingIds: Set<ComposeNodeId>) -> ZOrderPlan {
     // when the content is unchanged, no z-order maintenance is needed.
     if newIds == oldIds {
       return .minimal(needsNewItemPlacement: false)
@@ -139,7 +139,7 @@ extension ComposeView {
   ///   - reusingIds: The ids of the retained renderables.
   ///   - renderableItemIds: The ids of the renderables being rendered, in z-order (back to front).
   ///   - renderableMap: The map of the renderables being rendered, keyed by id.
-  func placeNewRenderables(reusingIds: Set<String>, renderableItemIds: [String], renderableMap: [String: Renderable]) {
+  func placeNewRenderables(reusingIds: Set<ComposeNodeId>, renderableItemIds: [ComposeNodeId], renderableMap: [ComposeNodeId: Renderable]) {
     let parent: View = contentView()
 
     // the next sibling of the same kind (already placed correctly), while walking from front to back

ComposeUI/Sources/ComposeUI/ComposeView/ComposeView.swift

@@ -121,21 +121,21 @@ open class ComposeView: BaseScrollView {
   private var lastRenderBounds: CGRect = .zero
 
   /// The ids of the renderable items that are being rendered.
-  private var renderableItemIds: [String] = []
+  private var renderableItemIds: [ComposeNodeId] = []
 
   /// The map of the renderable items that are being rendered.
-  private var renderableItemMap: [String: RenderableItem] = [:]
+  private var renderableItemMap: [ComposeNodeId: RenderableItem] = [:]
 
   /// The map of the renderables that are being rendered.
-  private var renderableMap: [String: Renderable] = [:]
+  private var renderableMap: [ComposeNodeId: Renderable] = [:]
 
   /// The map of the renderables that are being removed.
   ///
   /// The removing renderables are the ones that are not in the renderable hierarchy but still rendered due to the transition.
-  private var removingRenderableMap: [String: Renderable] = [:]
+  private var removingRenderableMap: [ComposeNodeId: Renderable] = [:]
 
   /// The map of the removing renderable transition completion blocks.
-  private var removingRenderableTransitionCompletionMap: [String: CancellableBlock] = [:]
+  private var removingRenderableTransitionCompletionMap: [ComposeNodeId: CancellableBlock] = [:]
 
   /// The pool that recycles renderables across render passes.
   ///
@@ -903,8 +903,8 @@ open class ComposeView: BaseScrollView {
     ComposeUI.assert(oldRenderableItemIds.count == oldRenderableItemMap.count, "mismatched old renderable item count")
     ComposeUI.assert(oldRenderableItemIds.count == oldRenderableMap.count, "mismatched old renderable count")
     for id in oldRenderableItemIds {
-      ComposeUI.assert(oldRenderableItemMap[id] != nil, "missing old renderable item: \(id)")
-      ComposeUI.assert(oldRenderableMap[id] != nil, "missing old renderable: \(id)")
+      ComposeUI.assert(oldRenderableItemMap[id] != nil, "missing old renderable item: \(id.id)")
+      ComposeUI.assert(oldRenderableMap[id] != nil, "missing old renderable: \(id.id)")
     }
     #endif
 
@@ -917,14 +917,14 @@ open class ComposeView: BaseScrollView {
     renderableMap.reserveCapacity(renderableItemsCount)
 
     for item in renderableItems {
-      let id = item.id.id
-      ComposeUI.assert(renderableItemMap[id] == nil, "conflicting renderable item id: \(id)")
+      let id = item.id
+      ComposeUI.assert(renderableItemMap[id] == nil, "conflicting renderable item id: \(id.id)")
       renderableItemIds.append(id)
       renderableItemMap[id] = item
     }
 
     // update the renderables
-    var reusingIds: Set<String> = []
+    var reusingIds: Set<ComposeNodeId> = []
 
     for oldId in oldRenderableItemIds {
       if renderableItemMap[oldId] == nil {
@@ -1012,7 +1012,7 @@ open class ComposeView: BaseScrollView {
             #endif
           }
         } else {
-          ComposeUI.assertFailure("old renderable item or old renderable not found: \(oldId)")
+          ComposeUI.assertFailure("old renderable item or old renderable not found: \(oldId.id)")
         }
       } else {
         // this renderable item is still in the content, plan to reuse it
@@ -1191,8 +1191,8 @@ open class ComposeView: BaseScrollView {
     ComposeUI.assert(renderableItemIds.count == renderableItemMap.count, "mismatched renderable item count")
     ComposeUI.assert(renderableItemIds.count == renderableMap.count, "mismatched renderable count")
     for id in renderableItemIds {
-      ComposeUI.assert(renderableItemMap[id] != nil, "missing renderable item: \(id)")
-      ComposeUI.assert(renderableMap[id] != nil, "missing renderable: \(id)")
+      ComposeUI.assert(renderableItemMap[id] != nil, "missing renderable item: \(id.id)")
+      ComposeUI.assert(renderableMap[id] != nil, "missing renderable: \(id.id)")
     }
     #endif
 
@@ -1255,11 +1255,11 @@ open class ComposeView: BaseScrollView {
       host.contentUpdateContext
     }
 
-    var removingRenderableMap: [String: Renderable] {
+    var removingRenderableMap: [ComposeNodeId: Renderable] {
       host.removingRenderableMap
     }
 
-    var removingRenderableTransitionCompletionMap: [String: CancellableBlock] {
+    var removingRenderableTransitionCompletionMap: [ComposeNodeId: CancellableBlock] {
       host.removingRenderableTransitionCompletionMap
     }
   }

ComposeUI/Tests/ComposeUITests/ComposeNode/ComposeNodeIdTests.swift

@@ -39,6 +39,23 @@ class ComposeNodeIdTests: XCTestCase {
     expect(id.id) == "C"
   }
 
+  func test_identity_ignoresIsFixed() {
+    let nonFixed = ComposeNodeId.custom("x", isFixed: false)
+    let fixed = ComposeNodeId.custom("x", isFixed: true)
+
+    expect(nonFixed) == fixed
+    expect(nonFixed.hashValue) == fixed.hashValue
+
+    var map: [ComposeNodeId: Int] = [:]
+    map[nonFixed] = 1
+    map[fixed] = 2
+    expect(map.count) == 1
+    expect(map[nonFixed]) == 2
+
+    // different id strings remain distinct.
+    expect(ComposeNodeId.custom("x")) != ComposeNodeId.custom("y")
+  }
+
   func test_custom() {
     let id = ComposeNodeId.custom("test")
     expect(id.id) == "test"
@@ -54,6 +71,46 @@ class ComposeNodeIdTests: XCTestCase {
     }
   }
 
+  func test_join_hashMatchesDirectId() {
+    let parentId = ComposeNodeId.custom("parent")
+    let childId = ComposeNodeId.custom("test")
+
+    do {
+      let joinedId = parentId.join(with: childId)
+      let directId = ComposeNodeId.custom("parent|test")
+      expect(joinedId) == directId
+      expect(joinedId.hashValue) == directId.hashValue
+
+      var map: [ComposeNodeId: Int] = [:]
+      map[joinedId] = 1
+      map[directId] = 2
+      expect(map.count) == 1
+      expect(map[joinedId]) == 2
+    }
+
+    do {
+      let joinedId = parentId.join(with: childId, suffix: "suffix")
+      let directId = ComposeNodeId.custom("parent|suffix|test")
+      expect(joinedId) == directId
+      expect(joinedId.hashValue) == directId.hashValue
+    }
+  }
+
+  func test_join_deepHashMatchesDirectId() {
+    var id = ComposeNodeId.custom("root")
+    var expectedId = "root"
+
+    for index in 0 ..< 20 {
+      let childId = ComposeNodeId.custom("child-\(index)")
+      id = id.join(with: childId, suffix: "suffix-\(index)")
+      expectedId += "|suffix-\(index)|child-\(index)"
+    }
+
+    let directId = ComposeNodeId.custom(expectedId)
+    expect(id) == directId
+    expect(id.hashValue) == directId.hashValue
+  }
+
   func test_custom_fixed() {
     let id = ComposeNodeId.custom("test", isFixed: true)
     expect(id.id) == "test"

ComposeUI/Tests/ComposeUITests/ComposeNode/ComposeNodeTests.swift

@@ -45,13 +45,20 @@ class ComposeNodeTests: XCTestCase {
     do {
       let node = MockComposeNode().id("test")
       expect(node.id) == .custom("test", isFixed: false)
+      expect(node.id.isSameConfiguration(as: .custom("test", isFixed: false))) == true
     }
 
     do {
       let node = MockComposeNode().fixedId("test")
       expect(node.id) == .custom("test", isFixed: true)
+      expect(node.id.isSameConfiguration(as: .custom("test", isFixed: true))) == true
     }
   }
+
+  func test_fixedId_appliesWhenIdStringUnchanged() {
+    let node = MockComposeNode().id("test").fixedId("test")
+    expect(ComposeNodeId.custom("parent").join(with: node.id).id) == "test"
+  }
 }
 
 private class MockComposeNode: ComposeNode {

ComposeUI/Tests/ComposeUITests/ComposeView/ComposeView+RenderReuseTests.swift

@@ -88,6 +88,41 @@ class ComposeView_RenderReuseTests: XCTestCase {
     expect(counter.madeCount) > initialMakeCount
   }
 
+  // MARK: - Render identity
+
+  func test_renderIdentity_ignoresIsFixed_reusesAcrossIsFixedChange() {
+    // A node id'd "x" (non-fixed) and the same node `fixedId`'d "x" are the SAME render item, because render identity is
+    // the id string only. Changing only the "isFixed" must therefore reuse the existing renderable in place rather than
+    // remove the old one and create a new one (which is what would happen if `isFixed` were part of the render map keys).
+    var madeCount = 0
+    let view = ComposeView(frame: CGRect(origin: .zero, size: Constants.viewSize))
+    view.renderablePool = nil // isolate map-based reuse from the recycle pool
+
+    view.setContent {
+      LayerNode(make: { _ in
+        madeCount += 1
+        return CALayer()
+      })
+      .id("x")
+    }
+    view.refresh(animated: false)
+    expect(madeCount) == 1
+
+    // same string id, now fixed: the render maps (renderableItemMap/renderableMap) must treat it as the same key.
+    view.setContent {
+      LayerNode(make: { _ in
+        madeCount += 1
+        return CALayer()
+      })
+      .fixedId("x")
+    }
+    view.refresh(animated: false)
+
+    // reused in place: no new renderable was created, and nothing was stranded in the removing map.
+    expect(madeCount) == 1
+    expect(view.test.removingRenderableMap.count) == 0
+  }
+
   // MARK: - Default pooling (common nodes)
 
   func test_colorNode_poolsByDefault_acrossScroll() {