If application runs in special thread, one should
call RWebWindowManager::AssignMainThrd() to indicate this

This enum will be removed shortly (functionality moved from TObject::Write to *::Merge)

This is necessary to support the 'fast' incremental merge where the input will continue to be used.

TIsAProxy:  Don't record failed searches (a library might be loaded between now and the next search).

Since fClass is modified only 'once' at init time of the IsAProxy object, it is actual more efficient
to protect the initialization by a lock rather than having fClass being atomic.

This allows to significant reduce the number of search through the list of cached result ...
That search was a noticeable cause of slow down with an increase of number threads due to the contention
on updating the number of readers (used for the local read/write lock mechanism).

To save space, the compression can be re-enabled by TBuffferMerger::SetCompressTemporaryKeys.

The TBaskets are still compressed and thus the end result is unchanged.

TClass::GetBaseClassOffset is a 'often' used routine in the I/O.
In the fast path (looking up in a cache), rather than taking the
global read lock (which is not only global but also 'slower' than
a regular mutex), we are now use a instance specific mutex to
protect the cache.

Add new enum for TObject::Write: kOnlyPrepStep  = BIT(3)         ///< Just prepare the objects do not write them (i.e. call TTree::FlushBaskets)

If TBufferMerger can take the merge lock, then rather than queuing the input file, merge it immediately
and skip the Writing the TTree, doing a memcpy, Pushing to the queue then Reading and then deleting parts.

Currently only in the case where we have a Merge function and a dictionary.

For iteration over the list of baskets, the existing code try to reduce the range of the iteration
to stop as soon as all non-nullptr slot have been seen.
However to know the number of non-nullptr slot, the code (has to) call GetEntries which scan the
entire array anyway ...

TObjArray::GetEntries() counts the number of non-zero slots
while TObjArray::GetEntriesFast() return (in most case) the value of a high water mark (the slot over which all remaining slots
are empty).

In one use case (doing read a TTree and do many TTree cloning (via TBufferMerger), TObjArray::GetEntries was taking 8% of the
running time (compression was disabled)

Note: TObjArray::IsEmpty use GetEntriesFast rather than GetEntries.

Limited to TTree and Histogram.

We do not apply the same to CloneTree as the addresses copying
is a side-effect (no reset at the end) that is relied upon by
user code.g

This can be used to monitor the queue size in bytes rather than number of files

This can now be safely use to avoid overloading the queue.

This speeds up the first step of merging (hadd)

This allow the fast cloning of the first tree in the list when using TTree::MergeTrees (rare)

When fMother is not set, first try to use fParent rather than iterate through
the TTree's list of top level branches

fParent was already set during the usual branch creation (TTree::Branch and friends) but
might still be not set if the user create a hierarchy by hand

... instead of just always ignoring it

apply this:
https://github.com/root-project/root/pull/7193#discussion_r585660675

change test limits taken from:
https://github.com/root-project/root/commit/fe5c74b5ed6045eb72091bad693f7af1fdf2266e