react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/ReactCommon/react/renderer/mounting/Differentiator.cpp

@@ -9,9 +9,11 @@
 
 #include <cxxreact/TraceSection.h>
 #include <react/debug/react_native_assert.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <algorithm>
 #include "internal/CullingContext.h"
 #include "internal/DiffMap.h"
+#include "internal/LongestIncreasingSubsequence.h"
 #include "internal/ShadowViewNodePair.h"
 #include "internal/sliceChildShadowNodeViewPairs.h"
 
@@ -680,7 +682,10 @@ static void calculateShadowViewMutationsFlattener(
               treeChildPair,
               (reparentMode == ReparentMode::Flatten
                    ? oldTreeNodePair.shadowView.tag
-                   : parentTag),
+                   : (ReactNativeFeatureFlags::
+                              fixDifferentiatorParentTagForUnflattenCase()
+                          ? parentTagForUpdate
+                          : parentTag)),
               subVisitedNewMap,
               subVisitedOldMap,
               cullingContextForUnvisitedOtherNodes,
@@ -884,6 +889,20 @@ static void calculateShadowViewMutations(
   // Lists of mutations
   auto mutationContainer = OrderedMutationInstructionContainer{};
 
+  if (ReactNativeFeatureFlags::
+          enableDifferentiatorMutationVectorPreallocation()) {
+    // Pre-allocate mutation sub-vectors based on expected child count to avoid
+    // repeated reallocations during diffing.
+    size_t estimatedSize = std::max(oldChildPairs.size(), newChildPairs.size());
+    mutationContainer.createMutations.reserve(estimatedSize);
+    mutationContainer.deleteMutations.reserve(estimatedSize);
+    mutationContainer.insertMutations.reserve(estimatedSize);
+    mutationContainer.removeMutations.reserve(estimatedSize);
+    mutationContainer.updateMutations.reserve(estimatedSize);
+    mutationContainer.downwardMutations.reserve(estimatedSize);
+    mutationContainer.destructiveDownwardMutations.reserve(estimatedSize);
+  }
+
   DEBUG_LOGS({
     LOG(ERROR) << "Differ Entry: Child Pairs of node: [" << parentTag << "]";
     LOG(ERROR) << "> Old Child Pairs: " << oldChildPairs;
@@ -1034,13 +1053,275 @@ static void calculateShadowViewMutations(
           oldCullingContext,
           newCullingContextCopy);
     }
+  } else if (ReactNativeFeatureFlags::useLISAlgorithmInDifferentiator()) {
+    // LIS-based Stage 4: find the Longest Increasing Subsequence of
+    // new-list positions among old children to minimize REMOVE/INSERT
+    // mutations. Items in the LIS maintain their relative order and
+    // don't need REMOVE+INSERT — only items outside the LIS are moved.
+    auto remainingOldCount = oldChildPairs.size() - lastIndexAfterFirstStage;
+    auto remainingNewCount = newChildPairs.size() - lastIndexAfterFirstStage;
+
+    // Build newRemainingPairs (required by updateMatchedPairSubtrees for
+    // flattening logic) and tag→index map for O(1) lookups in Step 1.
+    auto newRemainingPairs =
+        DiffMap<Tag, ShadowViewNodePair*>(remainingNewCount);
+    auto newTagToIndex = DiffMap<Tag, size_t>(remainingNewCount);
+    for (size_t i = lastIndexAfterFirstStage; i < newChildPairs.size(); i++) {
+      auto& newChildPair = *newChildPairs[i];
+      newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
+      newTagToIndex.insert({newChildPair.shadowView.tag, i});
+    }
+
+    // Step 1: Map old children to their positions in the new list.
+    std::vector<size_t> oldToNewPos(remainingOldCount);
+    std::vector<bool> oldExistsInNew(remainingOldCount, false);
+
+    for (size_t i = 0; i < remainingOldCount; i++) {
+      auto oldIdx = lastIndexAfterFirstStage + i;
+      Tag oldTag = oldChildPairs[oldIdx]->shadowView.tag;
+      auto it = newTagToIndex.find(oldTag);
+      if (it != newTagToIndex.end()) {
+        oldToNewPos[i] = it->second;
+        oldExistsInNew[i] = true;
+      }
+    }
+
+    // Step 2: Compute LIS of new-list positions.
+    auto inLIS = longestIncreasingSubsequence(oldToNewPos, oldExistsInNew);
+
+    auto deletionCandidatePairs = std::vector<const ShadowViewNodePair*>{};
+    deletionCandidatePairs.reserve(remainingOldCount);
+
+    // New-child-indexed flag: true = LIS match that stays in place.
+    auto isLISMatch = std::vector<bool>(remainingNewCount, false);
+
+    // Step 4: Process old children.
+    // CRITICAL: check newRemainingPairs at runtime (not the pre-computed
+    // oldExistsInNew). The flattener erases entries from newRemainingPairs
+    // as it consumes them during flatten/unflatten — using the pre-computed
+    // snapshot would cause double-processing of flattened nodes.
+    react_native_assert(inLIS.size() == remainingOldCount);
+    for (size_t i = 0; i < remainingOldCount; i++) {
+      auto oldIdx = lastIndexAfterFirstStage + i;
+      auto& oldChildPair = *oldChildPairs[oldIdx];
+      Tag oldTag = oldChildPair.shadowView.tag;
+
+      auto newIt = newRemainingPairs.find(oldTag);
+      if (newIt == newRemainingPairs.end()) {
+        // Not in new list or consumed by flattening -> REMOVE.
+        if (!oldChildPair.isConcreteView) {
+          continue;
+        }
+
+        DEBUG_LOGS({
+          LOG(ERROR) << "Differ LIS Branch: Removing deleted tag: "
+                     << oldChildPair << " with parent: [" << parentTag << "]";
+        });
+
+        // Edge case: complex (un)flattening — node exists in other tree.
+        if (oldChildPair.inOtherTree() &&
+            oldChildPair.otherTreePair->isConcreteView) {
+          const ShadowView& otherTreeView =
+              oldChildPair.otherTreePair->shadowView;
+          mutationContainer.removeMutations.push_back(
+              ShadowViewMutation::RemoveMutation(
+                  parentTag,
+                  otherTreeView,
+                  static_cast<int>(oldChildPair.mountIndex)));
+          continue;
+        }
+
+        mutationContainer.removeMutations.push_back(
+            ShadowViewMutation::RemoveMutation(
+                parentTag,
+                oldChildPair.shadowView,
+                static_cast<int>(oldChildPair.mountIndex)));
+        deletionCandidatePairs.push_back(&oldChildPair);
+
+      } else if (inLIS[i]) {
+        // In LIS -> stays in place, just UPDATE + subtree recursion.
+        auto& newChildPair = *newIt->second;
+
+        DEBUG_LOGS({
+          LOG(ERROR) << "Differ LIS Branch: Matched in-order (LIS) at old "
+                     << oldIdx << ": " << oldChildPair << " with parent: ["
+                     << parentTag << "]";
+        });
+
+        // For LIS matches with concrete-ness changes, we must use
+        // (true, false) to avoid generating INSERT in updateMatchedPair.
+        // INSERT mutations must be in new-child order (Step 5), not
+        // old-child order (Step 4). Generating INSERT here would put it
+        // out of order relative to Step 5's INSERTs.
+        bool concreteChanged =
+            oldChildPair.isConcreteView != newChildPair.isConcreteView;
+
+        updateMatchedPair(
+            mutationContainer,
+            true,
+            !concreteChanged,
+            parentTag,
+            oldChildPair,
+            newChildPair);
+
+        updateMatchedPairSubtrees(
+            scope,
+            mutationContainer,
+            newRemainingPairs,
+            oldChildPairs,
+            parentTag,
+            oldChildPair,
+            newChildPair,
+            oldCullingContext,
+            newCullingContext);
+
+        if (!concreteChanged) {
+          // Check if this LIS match was consumed by flattening.
+          // updateMatchedPairSubtrees may erase entries from
+          // newRemainingPairs during flatten/unflatten transitions.
+          // If consumed, the node was reparented elsewhere and needs
+          // REMOVE from this parent.
+          if (newRemainingPairs.find(oldTag) != newRemainingPairs.end()) {
+            isLISMatch[oldToNewPos[i] - lastIndexAfterFirstStage] = true;
+          } else if (oldChildPair.isConcreteView) {
+            if (oldChildPair.inOtherTree() &&
+                oldChildPair.otherTreePair->isConcreteView) {
+              mutationContainer.removeMutations.push_back(
+                  ShadowViewMutation::RemoveMutation(
+                      parentTag,
+                      oldChildPair.otherTreePair->shadowView,
+                      static_cast<int>(oldChildPair.mountIndex)));
+            } else {
+              mutationContainer.removeMutations.push_back(
+                  ShadowViewMutation::RemoveMutation(
+                      parentTag,
+                      oldChildPair.shadowView,
+                      static_cast<int>(oldChildPair.mountIndex)));
+              deletionCandidatePairs.push_back(&oldChildPair);
+            }
+          }
+        }
+        // concreteChanged: not in isLISMatch, Step 5 handles INSERT.
+
+      } else {
+        // In new list but NOT in LIS -> REMOVE from old position.
+        // Will be re-inserted at new position in Step 5.
+        auto& newChildPair = *newIt->second;
+
+        DEBUG_LOGS({
+          LOG(ERROR)
+              << "Differ LIS Branch: Matched out-of-order (not in LIS) at old "
+              << oldIdx << ": " << oldChildPair << " with parent: ["
+              << parentTag << "]";
+        });
+
+        updateMatchedPair(
+            mutationContainer,
+            true,
+            false,
+            parentTag,
+            oldChildPair,
+            newChildPair);
+
+        updateMatchedPairSubtrees(
+            scope,
+            mutationContainer,
+            newRemainingPairs,
+            oldChildPairs,
+            parentTag,
+            oldChildPair,
+            newChildPair,
+            oldCullingContext,
+            newCullingContext);
+      }
+    }
+
+    // Step 5: Process new children — INSERT + CREATE.
+    // Generate INSERT for every non-LIS-matched concrete new child.
+    // Only generate CREATE for genuinely new children (not in other tree
+    // from flattening).
+    for (size_t i = lastIndexAfterFirstStage; i < newChildPairs.size(); i++) {
+      auto& newChildPair = *newChildPairs[i];
+
+      if (!newChildPair.isConcreteView) {
+        continue;
+      }
+
+      // LIS matches stay in place — no INSERT needed.
+      if (isLISMatch[i - lastIndexAfterFirstStage]) {
+        continue;
+      }
+
+      DEBUG_LOGS({
+        LOG(ERROR) << "Differ LIS Branch: Inserting tag: " << newChildPair
+                   << " with parent: [" << parentTag << "]"
+                   << (newChildPair.inOtherTree() ? " (in other tree)" : "");
+      });
+
+      mutationContainer.insertMutations.push_back(
+          ShadowViewMutation::InsertMutation(
+              parentTag,
+              newChildPair.shadowView,
+              static_cast<int>(newChildPair.mountIndex)));
+
+      // Only CREATE genuinely new children (not matched by flattening).
+      if (!newChildPair.inOtherTree()) {
+        mutationContainer.createMutations.push_back(
+            ShadowViewMutation::CreateMutation(newChildPair.shadowView));
+
+        auto newCullingContextCopy =
+            newCullingContext.adjustCullingContextIfNeeded(newChildPair);
+
+        ViewNodePairScope innerScope{};
+        calculateShadowViewMutations(
+            innerScope,
+            mutationContainer.downwardMutations,
+            newChildPair.shadowView.tag,
+            {},
+            sliceChildShadowNodeViewPairsFromViewNodePair(
+                newChildPair, innerScope, false, newCullingContextCopy),
+            oldCullingContext,
+            newCullingContextCopy);
+      }
+    }
+
+    // Step 6: Generate DELETE for deletion candidates.
+    for (const auto* deletionCandidatePtr : deletionCandidatePairs) {
+      const auto& oldChildPair = *deletionCandidatePtr;
+
+      DEBUG_LOGS({
+        LOG(ERROR) << "Differ LIS Branch: Deleting removed tag: "
+                   << oldChildPair << " with parent: [" << parentTag << "]";
+      });
+
+      if (!oldChildPair.inOtherTree() && oldChildPair.isConcreteView) {
+        mutationContainer.deleteMutations.push_back(
+            ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
+        auto oldCullingContextCopy =
+            oldCullingContext.adjustCullingContextIfNeeded(oldChildPair);
+
+        ViewNodePairScope innerScope{};
+        auto grandChildPairs = sliceChildShadowNodeViewPairsFromViewNodePair(
+            oldChildPair, innerScope, false, oldCullingContextCopy);
+        calculateShadowViewMutations(
+            innerScope,
+            mutationContainer.destructiveDownwardMutations,
+            oldChildPair.shadowView.tag,
+            std::move(grandChildPairs),
+            {},
+            oldCullingContextCopy,
+            newCullingContext);
+      }
+    }
   } else {
+    // Existing greedy Stage 4 algorithm.
     // Collect map of tags in the new list
-    auto remainingCount = newChildPairs.size() - index;
+    auto remainingCount = newChildPairs.size() - lastIndexAfterFirstStage;
     auto newRemainingPairs = DiffMap<Tag, ShadowViewNodePair*>(remainingCount);
     auto newInsertedPairs = DiffMap<Tag, ShadowViewNodePair*>(remainingCount);
     auto deletionCandidatePairs = DiffMap<Tag, const ShadowViewNodePair*>{};
-    for (; index < newChildPairs.size(); index++) {
+    for (index = lastIndexAfterFirstStage; index < newChildPairs.size();
+         index++) {
       auto& newChildPair = *newChildPairs[index];
       newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
     }
@@ -1313,6 +1594,19 @@ static void calculateShadowViewMutations(
     }
   }
 
+  if (ReactNativeFeatureFlags::
+          enableDifferentiatorMutationVectorPreallocation()) {
+    mutations.reserve(
+        mutations.size() +
+        mutationContainer.destructiveDownwardMutations.size() +
+        mutationContainer.updateMutations.size() +
+        mutationContainer.removeMutations.size() +
+        mutationContainer.deleteMutations.size() +
+        mutationContainer.createMutations.size() +
+        mutationContainer.downwardMutations.size() +
+        mutationContainer.insertMutations.size());
+  }
+
   // All mutations in an optimal order:
   std::move(
       mutationContainer.destructiveDownwardMutations.begin(),
@@ -1358,7 +1652,6 @@ ShadowViewMutation::List calculateShadowViewMutations(
   ViewNodePairScope innerViewNodePairScope{};
 
   auto mutations = ShadowViewMutation::List{};
-  mutations.reserve(256);
 
   auto oldRootShadowView = ShadowView(oldRootShadowNode);
   auto newRootShadowView = ShadowView(newRootShadowNode);
@@ -1381,6 +1674,16 @@ ShadowViewMutation::List calculateShadowViewMutations(
       false /* allowFlattened */,
       {} /* layoutOffset */,
       {} /* cullingContext */);
+
+  if (ReactNativeFeatureFlags::
+          enableDifferentiatorMutationVectorPreallocation()) {
+    // Estimate ~2 mutations per view (create + insert or remove + delete).
+    mutations.reserve(
+        std::max(size_t(256), (sliceOne.size() + sliceTwo.size()) * 2));
+  } else {
+    mutations.reserve(256);
+  }
+
   calculateShadowViewMutations(
       innerViewNodePairScope,
       mutations,

package/ReactCommon/react/renderer/mounting/ShadowTree.cpp

@@ -8,6 +8,7 @@
 #include "ShadowTree.h"
 
 #include <cxxreact/TraceSection.h>
+#include <jsinspector-modern/tracing/PerformanceTracerSection.h>
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewShadowNode.h>
@@ -24,6 +25,19 @@ namespace facebook::react {
 
 namespace {
 const int MAX_COMMIT_ATTEMPTS_BEFORE_LOCKING = 3;
+
+std::string getShadowTreeCommitSourceName(ShadowTreeCommitSource source) {
+  switch (source) {
+    case ShadowTreeCommitSource::Unknown:
+      return "Unknown";
+    case ShadowTreeCommitSource::React:
+      return "React";
+    case ShadowTreeCommitSource::AnimationEndSync:
+      return "AnimationEndSync";
+    case ShadowTreeCommitSource::ReactRevisionMerge:
+      return "ReactRevisionMerge";
+  }
+}
 } // namespace
 
 using CommitStatus = ShadowTree::CommitStatus;
@@ -316,6 +330,13 @@ CommitStatus ShadowTree::tryCommit(
     const ShadowTreeCommitTransaction& transaction,
     const CommitOptions& commitOptions) const {
   TraceSection s("ShadowTree::commit");
+  jsinspector_modern::tracing::PerformanceTracerSection s1(
+      "commit",
+      "Renderer",
+      "\u269b Native",
+      nullptr,
+      "source",
+      getShadowTreeCommitSourceName(commitOptions.source));
 
   auto isReactBranch = ReactNativeFeatureFlags::enableFabricCommitBranching() &&
       commitOptions.source == CommitSource::React;
@@ -382,7 +403,11 @@ CommitStatus ShadowTree::tryCommit(
 
   telemetry.willLayout();
   telemetry.setAsThreadLocal();
-  newRootShadowNode->layoutIfNeeded(&affectedLayoutableNodes);
+  {
+    jsinspector_modern::tracing::PerformanceTracerSection s2(
+        "layout", "Renderer", "\u269b Native");
+    newRootShadowNode->layoutIfNeeded(&affectedLayoutableNodes);
+  }
   telemetry.unsetAsThreadLocal();
   telemetry.didLayout(static_cast<int>(affectedLayoutableNodes.size()));
 
@@ -400,7 +425,7 @@ CommitStatus ShadowTree::tryCommit(
     {
       std::scoped_lock dispatchLock(EventEmitter::DispatchMutex());
       updateMountedFlag(
-          currentRevision_.rootShadowNode->getChildren(),
+          oldRevision.rootShadowNode->getChildren(),
           newRootShadowNode->getChildren(),
           commitOptions.source);
     }

package/ReactCommon/react/renderer/mounting/internal/LongestIncreasingSubsequence.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/debug/react_native_assert.h>
+#include <algorithm>
+#include <vector>
+
+namespace facebook::react {
+
+/**
+ * Computes the Longest Increasing Subsequence (LIS) of the given
+ * sequence of values using O(n log n) patience sorting.
+ *
+ * Returns a vector<bool> of the same size as `values`, where
+ * result[i] == true means values[i] is part of the LIS.
+ *
+ * Only elements where include[i] == true are considered;
+ * elements with include[i] == false are ignored and will always
+ * be false in the result.
+ */
+inline std::vector<bool> longestIncreasingSubsequence(
+    const std::vector<size_t> &values,
+    const std::vector<bool> &include)
+{
+  react_native_assert(values.size() == include.size());
+
+  size_t n = values.size();
+  std::vector<bool> inLIS(n, false);
+
+  if (n == 0) {
+    return inLIS;
+  }
+
+  // Collect indices of included elements.
+  std::vector<size_t> indices;
+  indices.reserve(n);
+  for (size_t i = 0; i < n; i++) {
+    if (include[i]) {
+      indices.push_back(i);
+    }
+  }
+
+  if (indices.empty()) {
+    return inLIS;
+  }
+
+  // tails[i] = smallest tail value of all increasing subsequences
+  // of length i+1.
+  std::vector<size_t> tails;
+  // tailIndices[i] = index into `indices` whose value is tails[i].
+  std::vector<size_t> tailIndices;
+  // predecessor[k] = index into `indices` of the predecessor of
+  // indices[k] in the LIS, or -1 if none.
+  std::vector<int> predecessor(indices.size(), -1);
+
+  tails.reserve(indices.size());
+  tailIndices.reserve(indices.size());
+
+  for (size_t k = 0; k < indices.size(); k++) {
+    size_t val = values[indices[k]];
+
+    // Binary search for the first element in tails >= val.
+    auto it = std::lower_bound(tails.begin(), tails.end(), val);
+    auto pos = static_cast<size_t>(it - tails.begin());
+
+    if (it == tails.end()) {
+      tails.push_back(val);
+      tailIndices.push_back(k);
+    } else {
+      *it = val;
+      tailIndices[pos] = k;
+    }
+
+    if (pos > 0) {
+      predecessor[k] = static_cast<int>(tailIndices[pos - 1]);
+    }
+  }
+
+  // Reconstruct LIS by tracing predecessors from the last element.
+  int current = static_cast<int>(tailIndices.back());
+  while (current >= 0) {
+    inLIS[indices[static_cast<size_t>(current)]] = true;
+    current = predecessor[static_cast<size_t>(current)];
+  }
+
+  return inLIS;
+}
+
+} // namespace facebook::react