Replace TinyMap with std::unordered_map in Differentiator (facebook#55680)

Summary:

Replace TinyMap<Tag, X> with std::unordered_map<Tag, X>. There is no detectable regression in performance and code is simpler, let's remove TinyMap.

```
┌────────────────────────────┬──────────────────┬───────────────────────────────────┬───────────────┐
│         Benchmark          │ TinyMap (before) │ unordered_map + ctor size (after) │    Change     │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ 100 uncollapsable views    │ 1,499,917 ns     │ 1,343,333 ns                      │ -10.4%        │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ 1000 uncollapsable views   │ 52,148,021 ns    │ 44,131,792 ns                     │ -15.4%        │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ 100 views large props      │ 5,131,292 ns     │ 4,529,937 ns                      │ -11.7%        │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ 1000 views large props     │ 82,706,813 ns    │ 84,334,167 ns                     │ +2.0% (noise) │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ 1500 views large props     │ 61,470,542 ns    │ 62,976,646 ns                     │ +2.5% (noise) │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ deep (depth=5, breadth=4)  │ 32,672,583 ns    │ 30,700,542 ns                     │ -6.0%         │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ deep (depth=7, breadth=3)  │ 78,523,542 ns    │ 74,121,729 ns                     │ -5.6%         │
├────────────────────────────┼──────────────────┼───────────────────────────────────┼───────────────┤
│ deep (depth=10, breadth=2) │ 48,328,562 ns    │ 45,702,188 ns                     │ -5.4%         │
└────────────────────────────┴──────────────────┴───────────────────────────────────┴───────────────┘
```

Reviewed By: NickGerleman

Differential Revision: D90346356

Author: sammy-SC

packages/react-native/Libraries/Components/View/__tests__/View-benchmark-itest.js

@@ -17,6 +17,31 @@ import {View} from 'react-native';
 let root;
 let testViews: React.MixedElement;
 
+function createDeepViewHierarchy(depth: number, breadth: number): React.Node {
+  if (depth === 0) {
+    return (
+      <View
+        collapsable={false}
+        style={{width: 10, height: 10}}
+        nativeID="leaf"
+      />
+    );
+  }
+  const children = [];
+  for (let i = 0; i < breadth; i++) {
+    children.push(
+      <View
+        key={i}
+        collapsable={false}
+        nativeID={`d${depth.toString()}-${i.toString()}`}
+        style={{width: depth + 1, height: depth + 1}}>
+        {createDeepViewHierarchy(depth - 1, breadth)}
+      </View>,
+    );
+  }
+  return <View collapsable={false}>{children}</View>;
+}
+
 function createViewsWithLargeAmountOfPropsAndStyles(count: number): React.Node {
   let views: React.Node = null;
   for (let i = 0; i < count; i++) {
@@ -124,4 +149,28 @@ Fantom.unstable_benchmark
         root.destroy();
       },
     }),
+  )
+  .test.each(
+    [
+      [5, 4],
+      [7, 3],
+      [10, 2],
+    ],
+    ([depth, breadth]) =>
+      `render deep view hierarchy (depth=${depth.toString()}, breadth=${breadth.toString()})`,
+    () => {
+      Fantom.runTask(() => root.render(testViews));
+    },
+    ([depth, breadth]) => ({
+      beforeAll: () => {
+        // $FlowExpectedError[incompatible-type]
+        testViews = createDeepViewHierarchy(depth, breadth);
+      },
+      beforeEach: () => {
+        root = Fantom.createRoot();
+      },
+      afterEach: () => {
+        root.destroy();
+      },
+    }),
   );

packages/react-native/ReactCommon/react/renderer/animations/LayoutAnimationKeyFrameManager.cpp

@@ -256,8 +256,7 @@ LayoutAnimationKeyFrameManager::pullTransaction(
       //   Catch delete+create (reparenting) (this should be optimized away at
       //   the diffing level eventually?)
       // TODO: to prevent this step we could tag Remove/Insert mutations as
-      // being moves on the Differ level, since we know that there? We could use
-      // TinyMap here, but it's not exposed by Differentiator (yet).
+      // being moves on the Differ level, since we know that there?
       std::unordered_set<Tag> insertedTags;
       std::unordered_set<Tag> deletedTags;
       std::unordered_set<Tag>

packages/react-native/ReactCommon/react/renderer/mounting/Differentiator.cpp

@@ -11,9 +11,9 @@
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <algorithm>
+#include <unordered_map>
 #include "internal/CullingContext.h"
 #include "internal/ShadowViewNodePair.h"
-#include "internal/TinyMap.h"
 #include "internal/sliceChildShadowNodeViewPairs.h"
 
 #include "ShadowView.h"
@@ -58,7 +58,9 @@ static std::ostream& operator<<(
 
 #ifdef DEBUG_LOGS_DIFFER
 template <typename KeyT, typename ValueT>
-static std::ostream& operator<<(std::ostream& out, TinyMap<KeyT, ValueT>& map) {
+static std::ostream& operator<<(
+    std::ostream& out,
+    std::unordered_map<KeyT, ValueT>& map) {
   auto it = map.begin();
   if (it != map.end()) {
     out << *it->second;
@@ -143,7 +145,7 @@ struct OrderedMutationInstructionContainer {
 static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
-    TinyMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
+    std::unordered_map<Tag, ShadowViewNodePair*>& newRemainingPairs,
     std::vector<ShadowViewNodePair*>& oldChildPairs,
     Tag parentTag,
     const ShadowViewNodePair& oldPair,
@@ -164,11 +166,11 @@ static void calculateShadowViewMutationsFlattener(
     ReparentMode reparentMode,
     OrderedMutationInstructionContainer& mutationContainer,
     Tag parentTag,
-    TinyMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
     const ShadowViewNodePair& node,
     Tag parentTagForUpdate,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
     const CullingContext& cullingContextForUnvisitedOtherNodes,
     const CullingContext& cullingContext);
 
@@ -183,7 +185,7 @@ static void calculateShadowViewMutationsFlattener(
 static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
-    TinyMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
+    std::unordered_map<Tag, ShadowViewNodePair*>& newRemainingPairs,
     std::vector<ShadowViewNodePair*>& oldChildPairs,
     Tag parentTag,
     const ShadowViewNodePair& oldPair,
@@ -232,14 +234,16 @@ static void updateMatchedPairSubtrees(
     // Unflattening
     else {
       // Construct unvisited nodes map
-      auto unvisitedOldChildPairs = TinyMap<Tag, ShadowViewNodePair*>{};
       // We don't know where all the children of oldChildPair are
       // within oldChildPairs, but we know that they're in the same
       // relative order. The reason for this is because of flattening
       // + zIndex: the children could be listed before the parent,
       // interwoven with children from other nodes, etc.
       auto oldFlattenedNodes = sliceChildShadowNodeViewPairsFromViewNodePair(
           oldPair, scope, true, oldCullingContextCopy);
+      auto unvisitedOldChildPairs =
+          std::unordered_map<Tag, ShadowViewNodePair*>(
+              oldFlattenedNodes.size());
       for (size_t i = 0, j = 0;
            i < oldChildPairs.size() && j < oldFlattenedNodes.size();
            i++) {
@@ -422,11 +426,11 @@ static void calculateShadowViewMutationsFlattener(
     ReparentMode reparentMode,
     OrderedMutationInstructionContainer& mutationContainer,
     Tag parentTag,
-    TinyMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
     const ShadowViewNodePair& node,
     Tag parentTagForUpdate,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
-    TinyMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
     const CullingContext& cullingContextForUnvisitedOtherNodes,
     const CullingContext& cullingContext) {
   // Step 1: iterate through entire tree
@@ -445,8 +449,8 @@ static void calculateShadowViewMutationsFlattener(
 
   // Views in other tree that are visited by sub-flattening or
   // sub-unflattening
-  TinyMap<Tag, ShadowViewNodePair*> subVisitedOtherNewNodes{};
-  TinyMap<Tag, ShadowViewNodePair*> subVisitedOtherOldNodes{};
+  std::unordered_map<Tag, ShadowViewNodePair*> subVisitedOtherNewNodes{};
+  std::unordered_map<Tag, ShadowViewNodePair*> subVisitedOtherOldNodes{};
   auto subVisitedNewMap =
       (parentSubVisitedOtherNewNodes != nullptr ? parentSubVisitedOtherNewNodes
                                                 : &subVisitedOtherNewNodes);
@@ -456,7 +460,7 @@ static void calculateShadowViewMutationsFlattener(
 
   // Candidates for full tree creation or deletion at the end of this function
   auto deletionCreationCandidatePairs =
-      TinyMap<Tag, const ShadowViewNodePair*>{};
+      std::unordered_map<Tag, const ShadowViewNodePair*>(treeChildren.size());
 
   for (size_t index = 0;
        index < treeChildren.size() && index < treeChildren.size();
@@ -471,7 +475,7 @@ static void calculateShadowViewMutationsFlattener(
              : subVisitedNewMap->end());
     auto subVisitedOtherOldIt =
         (unvisitedIt == unvisitedOtherNodes.end() &&
-                 (subVisitedNewMap->end() != nullptr)
+                 subVisitedOtherNewIt == subVisitedNewMap->end()
              ? subVisitedOldMap->find(treeChildPair.shadowView.tag)
              : subVisitedOldMap->end());
 
@@ -697,7 +701,8 @@ static void calculateShadowViewMutationsFlattener(
                   : adjustedOldCullingContext);
           // Construct unvisited nodes map
           auto unvisitedRecursiveChildPairs =
-              TinyMap<Tag, ShadowViewNodePair*>{};
+              std::unordered_map<Tag, ShadowViewNodePair*>(
+                  flattenedNodes.size());
           for (auto& flattenedNode : flattenedNodes) {
             auto& newChild = *flattenedNode;
 
@@ -756,9 +761,6 @@ static void calculateShadowViewMutationsFlattener(
             // loop of this function.
             for (auto& unvisitedRecursiveChildPair :
                  unvisitedRecursiveChildPairs) {
-              if (unvisitedRecursiveChildPair.first == 0) {
-                continue;
-              }
               auto& oldFlattenedNode = *unvisitedRecursiveChildPair.second;
 
               // Node unvisited - mark the entire subtree for deletion
@@ -820,9 +822,6 @@ static void calculateShadowViewMutationsFlattener(
   // subtrees if they were never visited during the execution of the above
   // loop and recursions.
   for (auto& deletionCreationCandidatePair : deletionCreationCandidatePairs) {
-    if (deletionCreationCandidatePair.first == 0) {
-      continue;
-    }
     auto& treeChildPair = *deletionCreationCandidatePair.second;
 
     // If node was visited during a flattening/unflattening recursion,
@@ -1042,9 +1041,13 @@ static void calculateShadowViewMutations(
     }
   } else {
     // Collect map of tags in the new list
-    auto newRemainingPairs = TinyMap<Tag, ShadowViewNodePair*>{};
-    auto newInsertedPairs = TinyMap<Tag, ShadowViewNodePair*>{};
-    auto deletionCandidatePairs = TinyMap<Tag, const ShadowViewNodePair*>{};
+    auto remainingCount = newChildPairs.size() - index;
+    auto newRemainingPairs =
+        std::unordered_map<Tag, ShadowViewNodePair*>(remainingCount);
+    auto newInsertedPairs =
+        std::unordered_map<Tag, ShadowViewNodePair*>(remainingCount);
+    auto deletionCandidatePairs =
+        std::unordered_map<Tag, const ShadowViewNodePair*>{};
     for (; index < newChildPairs.size(); index++) {
       auto& newChildPair = *newChildPairs[index];
       newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
@@ -1243,10 +1246,6 @@ static void calculateShadowViewMutations(
     // list to make sure that a node was not reparented into an unflattened
     // node that occurs *after* it in the hierarchy, due to zIndex ordering.
     for (auto& deletionCandidatePair : deletionCandidatePairs) {
-      if (deletionCandidatePair.first == 0) {
-        continue;
-      }
-
       const auto& oldChildPair = *deletionCandidatePair.second;
 
       DEBUG_LOGS({
@@ -1285,14 +1284,6 @@ static void calculateShadowViewMutations(
     // Final step: generate Create instructions for entirely new
     // subtrees/nodes that are not the result of flattening or unflattening.
     for (auto& newInsertedPair : newInsertedPairs) {
-      // Erased elements of a TinyMap will have a Tag/key of 0 - skip those
-      // These *should* be removed by the map; there are currently no KNOWN
-      // cases where TinyMap will do the wrong thing, but there are not yet
-      // any unit tests explicitly for TinyMap, so this is safer for now.
-      if (newInsertedPair.first == 0) {
-        continue;
-      }
-
       const auto& newChildPair = *newInsertedPair.second;
 
       DEBUG_LOGS({