Enh 36428544 - [36428529->24.09] Reduce the overhead of key set manipulation when applying indexes

[git-p4: depot-paths = "//dev/coherence-ce/main/": change = 107792]

Author: aseovic

prj/coherence-core/src/main/java/com/tangosol/internal/util/UnsafeSubSet.java

@@ -1,12 +1,13 @@
 /*
- * Copyright (c) 2000, 2023, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
  * https://oss.oracle.com/licenses/upl.
  */
 
 package com.tangosol.internal.util;
 
+import com.tangosol.util.Base;
 import com.tangosol.util.SubSet;
 
 import com.tangosol.net.BackingMapManagerContext;
@@ -16,7 +17,6 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -244,7 +244,7 @@ protected Set<E> collectSet(Collection<E> col)
         // partitions requested (parts) and the service owned partitions equals
         // each other. However, since there might be a transfer in-flight, the
         // collection could contain keys from "unowned" partitions
-        Set<E> set = new HashSet<E>(col.size());
+        Set<E> set = Base.newHashSet(col.size());
         for (E key : col)
             {
             if (parts.contains(ctx.getKeyPartition(key)))

prj/coherence-core/src/main/java/com/tangosol/util/Base.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2023, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
  * https://oss.oracle.com/licenses/upl.
@@ -46,6 +46,8 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
@@ -59,6 +61,86 @@
 @SuppressWarnings({"unused", "deprecation"})
 public abstract class Base
     {
+    // ----- factory methods for hashing collections ------------------------
+
+    /**
+     * Construct an instance of {@link HashSet} with a desired number of elements
+     * and a load factor.
+     *
+     * @param cElements     the desired number of elements
+     * @param flLoadFactor  the load factor
+     *
+     * @return an instance of a {@code HashSet}
+     *
+     * @param <E> the type of set elements
+     */
+    public static <E> HashSet<E> newHashSet(int cElements, float flLoadFactor)
+        {
+        return new HashSet<>(calculateCapacity(cElements, flLoadFactor), flLoadFactor);
+        }
+
+    /**
+     * Construct an instance of {@link HashSet} with a desired number of elements
+     * and a default load factor.
+     *
+     * @param cElements  the desired number of elements
+     *
+     * @return an instance of a {@code HashSet}
+     *
+     * @param <E> the type of set elements
+     */
+    public static <E> HashSet<E> newHashSet(int cElements)
+        {
+        return newHashSet(cElements, DEFAULT_LOAD_FACTOR);
+        }
+
+    /**
+     * Construct an instance of {@link HashMap} with a desired number of entries
+     * and a load factor.
+     *
+     * @param cEntries      the desired number of entries
+     * @param flLoadFactor  the load factor
+     *
+     * @return an instance of a {@code HashMap}
+     *
+     * @param <K> the type of map keys
+     * @param <V> the type of map values
+     */
+    public static <K, V> HashMap<K, V> newHashMap(int cEntries, float flLoadFactor)
+        {
+        return new HashMap<>(calculateCapacity(cEntries, flLoadFactor), flLoadFactor);
+        }
+
+    /**
+     * Construct an instance of {@link HashMap} with a desired number of entries
+     * and a default load factor (0.75).
+     *
+     * @param cEntries  the desired number of entries
+     *
+     * @return an instance of a {@code HashMap}
+     *
+     * @param <K> the type of map keys
+     * @param <V> the type of map values
+     */
+    public static <K, V> HashMap<K, V> newHashMap(int cEntries)
+        {
+        return newHashMap(cEntries, DEFAULT_LOAD_FACTOR);
+        }
+
+    /**
+     * Calculate capacity of a HashSet or HashMap that will require no rehashing
+     * unless the specified maximum number of elements/entries is exceeded.
+     *
+     * @param cMaxElements   the maximum expected number of elements/entries
+     * @param dblLoadFactor  the desired load factor
+     *
+     * @return a capacity to create a HashSet or a HashMap with
+     */
+    private static int calculateCapacity(int cMaxElements, double dblLoadFactor)
+        {
+        return (int) Math.ceil(cMaxElements / dblLoadFactor);
+        }
+
     // ----- debugging support:  expression evaluation ----------------------
 
     /**
@@ -2881,6 +2963,11 @@ public void println()
      */
     public static final int LOG_QUIET = 6;
 
+    /**
+     * Default load factor for hashing collections.
+     */
+    public static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
     // ----- data members ---------------------------------------------------
 
     /**

prj/coherence-core/src/main/java/com/tangosol/util/ChainedCollection.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2023, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
  * https://oss.oracle.com/licenses/upl.
@@ -21,6 +21,7 @@
  * @author hr  2014.02.19
  * @since Coherence 12.1.2
  */
+@SuppressWarnings("unchecked")
 public class ChainedCollection<E>
         extends AbstractCollection<E>
     {
@@ -34,7 +35,7 @@ public class ChainedCollection<E>
      */
     public ChainedCollection(Collection<Collection<E>> col)
         {
-        this(col.toArray(new Collection[col.size()]));
+        this(col.toArray(Collection[]::new));
         }
 
     /**
@@ -70,8 +71,7 @@ public ChainedCollection(ChainedCollection<E> original, Collection<E>... aCol)
      *
      * @param aCol  an array of Collection objects
      */
-    @SafeVarargs
-    public ChainedCollection(Collection<E>... aCol)
+    public ChainedCollection(Collection<E>[] aCol)
         {
         f_aCol = aCol;
         }

prj/coherence-core/src/main/java/com/tangosol/util/filter/AnyFilter.java

@@ -8,12 +8,14 @@
 package com.tangosol.util.filter;
 
 
+import com.tangosol.util.ChainedCollection;
 import com.tangosol.util.Filter;
 import com.tangosol.util.QueryContext;
 import com.tangosol.util.QueryRecord;
 import com.tangosol.util.SubSet;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -26,6 +28,7 @@
 *
 * @author cp/gg 2002.11.01
 */
+@SuppressWarnings({"unchecked", "rawtypes"})
 public class AnyFilter
         extends ArrayFilter
     {
@@ -152,35 +155,41 @@ protected Filter applyIndex(Map mapIndexes, Set setKeys, QueryContext ctx,
         {
         optimizeFilterOrder(mapIndexes, setKeys);
 
-        Filter[] aFilter    = getFilters();
-        int      cFilters   = aFilter.length;
-        List     listFilter = new ArrayList(cFilters);
-        Set      setMatch   = new HashSet(setKeys.size());
+        Filter[]        aFilter    = getFilters();
+        int             cFilters   = aFilter.length;
 
-        // listFilter is an array of filters that will have to be re-applied
-        // setMatch   is an accumulating set of already matching keys
+        // a list of filters that will have to be re-applied
+        List<Filter<?>> listFilter = new ArrayList<>(cFilters);
 
-        SubSet setRemain = new SubSet(setKeys);
-        for (int i = cFilters - 1; i >= 0; i--)    // iterate backwards, to reduce the set of remaining keys as quickly as possible
+        // a list of sets of matching keys, which will be subsequently merged
+        // into a set of keys that should be retained; doing it this way, instead
+        // of simply creating a set and calling addAll on it for each filter
+        // avoids set resizing and rehashing of the keys
+        List<Set<?>>    listMatch  = new ArrayList<>(cFilters);
+
+        // iterate backwards, from the least selective filter to the most selective one,
+        // to ensure that the largest sets of matching keys are at the beginning
+        // of a ChainedCollection, making subsequent retainAll call faster
+        for (int i = cFilters - 1; i >= 0; i--)
             {
             Filter filter = aFilter[i];
             if (filter instanceof IndexAwareFilter)
                 {
+                SubSet setRemain   = new SubSet(setKeys);
                 Filter filterDefer = applyFilter(filter, i, mapIndexes, setRemain, ctx, step);
-                Set    setRemoved  = setRemain.getRemoved();
                 Set    setRetained = setRemain.getRetained();
 
                 if (filterDefer == null)
                     {
-                    // these are definitely "in"
-                    setMatch.addAll(setRetained);
-                    
-                    // reset setRemain to contain only the keys that were removed
-                    setRemain = new SubSet(setRemoved);
+                    if (!setRetained.isEmpty())
+                        {
+                        // these are definitely "in"
+                        listMatch.add(setRetained);
+                        }
                     }
                 else
                     {
-                    if (!setRemoved.isEmpty())
+                    if (!setRemain.getRemoved().isEmpty())
                         {
                         // some keys are definitely "out" for this filter;
                         // we need to incorporate this knowledge into a deferred
@@ -201,11 +210,6 @@ protected Filter applyIndex(Map mapIndexes, Set setKeys, QueryContext ctx,
                         {
                         listFilter.add(filterDefer);
                         }
-
-                    // we have to reset setRemain it to contain all the keys
-                    // that are not definite matches
-                    setRemain = new SubSet(setKeys);
-                    setRemain.removeAll(setMatch);
                     }
                 }
             else if (filter != null)
@@ -214,37 +218,38 @@ else if (filter != null)
                 }
             }
 
-        int cMatches = setMatch.size();
+        // create a set containing all the matches identified by individual filters
+        Set<?> setMatches = new HashSet<>(new ChainedCollection<>(listMatch.toArray(Set[]::new)));
 
         cFilters = listFilter.size();
         if (cFilters == 0)
             {
-            if (cMatches > 0)
+            if (setMatches.isEmpty())
                 {
-                setKeys.retainAll(setMatch);
+                setKeys.clear();
                 }
             else
                 {
-                setKeys.clear();
+                setKeys.retainAll(setMatches);
                 }
             return null;
             }
-        else if (cFilters == 1 && cMatches == 0)
+        else if (cFilters == 1 && setMatches.isEmpty())
             {
-            return (Filter) listFilter.get(0);
+            return listFilter.get(0);
             }
         else
             {
-            if (cMatches > 0)
+            if (!setMatches.isEmpty())
                 {
                 // the keys that have been matched are definitely "in";
                 // the remaining keys each need to be evaluated later
-                KeyFilter filterKey = new KeyFilter(setMatch);
+                KeyFilter filterKey = new KeyFilter(setMatches);
                 listFilter.add(0, filterKey);
                 cFilters++;
                 }
 
-            return new AnyFilter((Filter[]) listFilter.toArray(new Filter[cFilters]));
+            return new AnyFilter(listFilter.toArray(new Filter[cFilters]));
             }
         }