Add cloneMultiple method to the ShadowNode class

[bartlomiejbloniarz]

Summary:

This PR adds a new cloning method, allowing for updating multiple nodes in a single transaction. It works in two phases:

1. Find which nodes have to be cloned (i.e. nodes given on input and all their ancestors)
2. Clone nodes in the bottom up order - so that every node is cloned exactly once

So the idea is that when we want to update all the red nodes in this picture, we first find the nodes in the green area and the clone only them in the correct order (children are cloned before parents):

Adapting this method brought a huge performance gain to reanimated. I want to upstream it, so that:

1. we can optimize it further, because making it a part of the ShadowNode class gives us access to the parent field in ShadowNodeFamily so we can traverse the tree upwards, allowing for a optimal implementation of the first phase (in reanimated we repeatedly call getAncestors, which revisits some nodes multiple times)
2. the community can use it

A naive approach that calls cloneTree for every node is much slower, as it has to repeat many operations.

Changelog:

[GENERAL] [ADDED] - Added cloneMultiple to ShadowNode class.

Test Plan:

I tested it with the following reanimated implementation and everything works fine:

const auto callback =
      [&](const ShadowNode &shadowNode,
          const std::optional<ShadowNode::ListOfShared> &newChildren) {
        return shadowNode.clone(
            {mergeProps(shadowNode, propsMap, shadowNode.getFamily()),
             newChildren
                 ? std::make_shared<ShadowNode::ListOfShared>(*newChildren)
                 : ShadowNodeFragment::childrenPlaceholder(),
             shadowNode.getState()});
      };
  return std::static_pointer_cast<RootShadowNode>(
      oldRootNode.cloneMultiple(families, callback));

I would like to add tests for it, but I'm not sure what's the best approach for that in the repo.

[tomekzaw]

Suggested change

	std::unordered_map<const ShadowNodeFamily*, int> childrenCount;
	std::unordered_map<const std::ref<const ShadowNodeFamily>, unsigned int> childrenCounts;

[tomekzaw]

Let's pass ShadowNodeFamily as a std::ref instead of a pointer maybe?

Suggested change

	const std::unordered_set<const ShadowNodeFamily*>& families,
	const std::unordered_set<const ShadowNodeFamily &>& families,

[tomekzaw]

Let's also explain why newChildren is optional.

[tomekzaw]

Let's also mention what happens if callback returns nullptr?

[tomekzaw]

Do we need to be that explicit about the return type?

Suggested change

	return ShadowNode::Unshared{nullptr};
	return nullptr;

[javache]

Since these methods don't actually need to live on ShadowNode, what about creating a ShadowNodeMutations helper class (and defining it as a friend class if necessary)

[javache]

Instead of using pointers to ShadowNodeFamily, let's try to use refs, eg using std::reference_wrapper

[bartlomiejbloniarz]

I tried that. The problem with it is that I use unordered containers, so that would require implementing hash methods for the family.

For now I changed the loop over ancestors, to lock the weak pointer, so that when we access any fields of a family, we are sure it's still around. After that we only compare these pointers as numbers - we never dereference them so it will be safe. This would only fail if someone passed familiesToUpdate to the function, without owning them. In reanimated we keep shared_ptrs of ShadowNodes related to these families to ensure that they are still available when we perform the algorithm.

What do you think?

[bartlomiejbloniarz]

We could change the api to instead work with shared_ptrs. The problem is that users of this api (so for example reanimated), don't have access to shared_ptrs of the ShadowNodeFamily class, as you only can get a reference from the ShadowNode.getFamily() method.

[javache]

Avoid copying the list

Suggested change

	auto children = shadowNode.getChildren();
	const auto& children = shadowNode.getChildren();

[bartlomiejbloniarz]

I am copying that on purpose, as I want to modify it later on in the loop.

[javache]

Is this familiesToUpdate?

[bartlomiejbloniarz]

Will rename

[javache]

Pass in a ShadowNodeFragment instead of children explicitly

[bartlomiejbloniarz]

@javache Sure I can extract it to a separate file. Should I also move the cloneTree function? I wanted the cloneMultiple function to be a generalization of that.