ConditionalWeakTable - don't link Containers when no entries are transferred (#108941)

ConditionalWeakTable uses internal Container objects for the underlying table.  Container entries are write-once because the read path is lock-free.  When a Container is full, a new Container is allocated, entries are copied, and compaction can occur (if there aren't any currently live enumerators relying on specific indices).

A two-pass finalization scheme is used to free the entries (dependent handles) and then the Containers themselves.  Finalization provides a guarantee that the Container is no longer in use, and the second pass accounts for finalization resurrection.  Because entries can be duplicated across Containers, each Container contains a link to the one that replaces it. 
 This can _greatly_ extend the lifetime of Containers.  (See #50683 and #108447.)

However, if the Container is empty and not being enumerated, there is no need to link it to the next Container.  This PR handles that case, which includes microbenchmarks where single entries are added and removed from ConditionalWeakTable and equivalent tests where TransactionScope is functioning as a wrapper around a ConditionalWeakTable entry.  Of course, this is only a partial solution because a single live entry or enumerator leaves the old behavior.  Another caveat is that the finalization queue can be filled faster than it can be emptied, though this is more likely in microbenchmarks where other work isn't being done.

Author: markples

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs

@@ -698,10 +698,13 @@ internal Container Resize(int newSize)
                 Entry[] newEntries = new Entry[newSize];
                 int newEntriesIndex = 0;
                 bool activeEnumerators = _parent != null && _parent._activeEnumeratorRefCount > 0;
+                bool transferredHandles;
 
                 // Migrate existing entries to the new table.
                 if (activeEnumerators)
                 {
+                    transferredHandles = true;
+
                     // There's at least one active enumerator, which means we don't want to
                     // remove any expired/removed entries, in order to not affect existing
                     // entries indices.  Copy over the entries while rebuilding the buckets list,
@@ -721,6 +724,8 @@ internal Container Resize(int newSize)
                 }
                 else
                 {
+                    transferredHandles = false;
+
                     // There are no active enumerators, which means we want to compact by
                     // removing expired/removed entries.
                     for (int entriesIndex = 0; entriesIndex < _entries.Length; entriesIndex++)
@@ -732,6 +737,8 @@ internal Container Resize(int newSize)
                         {
                             if (depHnd.UnsafeGetTarget() is not null)
                             {
+                                transferredHandles = true;
+
                                 ref Entry newEntry = ref newEntries[newEntriesIndex];
 
                                 // Entry is used and has not expired. Link it into the appropriate bucket list.
@@ -765,7 +772,13 @@ internal Container Resize(int newSize)
                     // from being finalized, as it no longer has any responsibility for any cleanup.
                     GC.SuppressFinalize(this);
                 }
-                _oldKeepAlive = newContainer; // once this is set, the old container's finalizer will not free transferred dependent handles
+
+                if (transferredHandles)
+                {
+                    // Once this is set, the old container's finalizer will not free transferred dependent handles,
+                    // and the new container's finalizer can't be run until this container is no longer in use.
+                    _oldKeepAlive = newContainer;
+                }
 
                 GC.KeepAlive(this); // ensure we don't get finalized while accessing DependentHandles.